@codingame/monaco-vscode-extensions-service-override 17.2.1 → 18.0.1

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

@@ -20,14 +20,20 @@ import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ExtensionHostKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionHostKind';
+import { IURLService } from '@codingame/monaco-vscode-api/vscode/vs/platform/url/common/url.service';
+import { DeferredPromise, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IDynamicAuthenticationProviderStorageService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/dynamicAuthenticationProviderStorage.service';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
 
 class MainThreadAuthenticationProvider extends Disposable {
-    constructor(_proxy, id, label, supportsMultipleAccounts, notificationService, onDidChangeSessionsEmitter) {
+    constructor(_proxy, id, label, supportsMultipleAccounts, authorizationServers, notificationService, onDidChangeSessionsEmitter) {
         super();
         this._proxy = _proxy;
         this.id = id;
         this.label = label;
         this.supportsMultipleAccounts = supportsMultipleAccounts;
+        this.authorizationServers = authorizationServers;
         this.notificationService = notificationService;
         this.onDidChangeSessions = onDidChangeSessionsEmitter.event;
     }
@@ -39,11 +45,11 @@ class MainThreadAuthenticationProvider extends Disposable {
     }
     async removeSession(sessionId) {
         await this._proxy.$removeSession(this.id, sessionId);
-        this.notificationService.info(( localize(2381, "Successfully signed out.")));
+        this.notificationService.info(( localize(2387, "Successfully signed out.")));
     }
 }
 let MainThreadAuthentication = class MainThreadAuthentication extends Disposable {
-    constructor(extHostContext, authenticationService, authenticationExtensionsService, authenticationAccessService, authenticationUsageService, dialogService, notificationService, extensionService, telemetryService, openerService, logService) {
+    constructor(extHostContext, authenticationService, authenticationExtensionsService, authenticationAccessService, authenticationUsageService, dialogService, notificationService, extensionService, telemetryService, openerService, logService, urlService, dynamicAuthProviderStorageService, clipboardService) {
         super();
         this.authenticationService = authenticationService;
         this.authenticationExtensionsService = authenticationExtensionsService;
@@ -55,36 +61,55 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         this.telemetryService = telemetryService;
         this.openerService = openerService;
         this.logService = logService;
+        this.urlService = urlService;
+        this.dynamicAuthProviderStorageService = dynamicAuthProviderStorageService;
+        this.clipboardService = clipboardService;
         this._registrations = this._register(( new DisposableMap()));
         this._sentProviderUsageEvents = ( new Set());
         this._sentClientIdUsageEvents = ( new Set());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostAuthentication));
-        this._register(this.authenticationService.onDidChangeSessions(e => {
-            this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label);
-        }));
+        this._register(this.authenticationService.onDidChangeSessions(e => this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label)));
+        this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(e => this._proxy.$onDidUnregisterAuthenticationProvider(e.id)));
         this._register(this.authenticationExtensionsService.onDidChangeAccountPreference(e => {
             const providerInfo = this.authenticationService.getProvider(e.providerId);
             this._proxy.$onDidChangeAuthenticationSessions(providerInfo.id, providerInfo.label, e.extensionIds);
         }));
+        this._register(this.dynamicAuthProviderStorageService.onDidChangeTokens(e => {
+            this._proxy.$onDidChangeDynamicAuthProviderTokens(e.authProviderId, e.clientId, e.tokens);
+        }));
+        this._register(authenticationService.registerAuthenticationProviderHostDelegate({
+            priority: extHostContext.extensionHostKind === ExtensionHostKind.LocalWebWorker ? 0 : 1,
+            create: async (authorizationServer, serverMetadata, resource) => {
+                const authProviderId = ( authorizationServer.toString(true));
+                const clientId = this.dynamicAuthProviderStorageService.getClientId(authProviderId);
+                let initialTokens = undefined;
+                if (clientId) {
+                    initialTokens = await this.dynamicAuthProviderStorageService.getSessionsForDynamicAuthProvider(authProviderId, clientId);
+                }
+                return await this._proxy.$registerDynamicAuthProvider(authorizationServer, serverMetadata, resource, clientId, initialTokens);
+            }
+        }));
     }
-    async $registerAuthenticationProvider(id, label, supportsMultipleAccounts) {
+    async $registerAuthenticationProvider(id, label, supportsMultipleAccounts, supportedAuthorizationServer = []) {
         if (!this.authenticationService.declaredProviders.find(p => p.id === id)) {
             this.logService.warn(`Authentication provider ${id} was not declared in the Extension Manifest.`);
             this.telemetryService.publicLog2('authentication.providerNotDeclared', { id });
         }
         const emitter = ( new Emitter());
         this._registrations.set(id, emitter);
+        const supportedAuthorizationServerUris = ( supportedAuthorizationServer.map(i => URI.revive(i)));
         const provider = ( new MainThreadAuthenticationProvider(
             this._proxy,
             id,
             label,
             supportsMultipleAccounts,
+            supportedAuthorizationServerUris,
             this.notificationService,
             emitter
         ));
         this.authenticationService.registerAuthenticationProvider(id, provider);
     }
-    $unregisterAuthenticationProvider(id) {
+    async $unregisterAuthenticationProvider(id) {
         this._registrations.deleteAndDispose(id);
         this.authenticationService.unregisterAuthenticationProvider(id);
     }
@@ -93,7 +118,7 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
             return await this.extensionService.activateByEvent(getAuthenticationProviderActivationEvent(id), ActivationKind.Immediate);
         }
     }
-    $sendDidChangeSessions(providerId, event) {
+    async $sendDidChangeSessions(providerId, event) {
         const obj = this._registrations.get(providerId);
         if (obj instanceof Emitter) {
             obj.fire(event);
@@ -102,11 +127,54 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
     $removeSession(providerId, sessionId) {
         return this.authenticationService.removeSession(providerId, sessionId);
     }
+    async $waitForUriHandler(expectedUri) {
+        const deferredPromise = ( new DeferredPromise());
+        const disposable = this.urlService.registerHandler({
+            handleURL: async (uri) => {
+                if (uri.scheme !== expectedUri.scheme || uri.authority !== expectedUri.authority || uri.path !== expectedUri.path) {
+                    return false;
+                }
+                deferredPromise.complete(uri);
+                disposable.dispose();
+                return true;
+            }
+        });
+        const result = await raceTimeout(deferredPromise.p, 5 * 60 * 1000);
+        if (!result) {
+            throw ( new Error('Timed out waiting for URI handler'));
+        }
+        return await deferredPromise.p;
+    }
+    $showContinueNotification(message) {
+        const yes = ( localize(2388, "Yes"));
+        const no = ( localize(2389, "No"));
+        const deferredPromise = ( new DeferredPromise());
+        let result = false;
+        const handle = this.notificationService.prompt(Severity.Warning, message, [{
+                label: yes,
+                run: () => result = true
+            }, {
+                label: no,
+                run: () => result = false
+            }]);
+        const disposable = handle.onDidClose(() => {
+            deferredPromise.complete(result);
+            disposable.dispose();
+        });
+        return deferredPromise.p;
+    }
+    async $registerDynamicAuthenticationProvider(id, label, authorizationServer, clientId) {
+        await this.$registerAuthenticationProvider(id, label, false, [authorizationServer]);
+        this.dynamicAuthProviderStorageService.storeClientId(id, ( URI.revive(authorizationServer).toString(true)), clientId, label);
+    }
+    async $setSessionsForDynamicAuthProvider(authProviderId, clientId, sessions) {
+        await this.dynamicAuthProviderStorageService.setSessionsForDynamicAuthProvider(authProviderId, clientId, sessions);
+    }
     async loginPrompt(provider, extensionName, recreatingSession, options) {
         let message;
         if (provider.id.startsWith(INTERNAL_AUTH_PROVIDER_PREFIX)) {
             message = ( localize(
-                2382,
+                2390,
                 "The extension '{0}' wants to access the language models provided by {1}.",
                 extensionName,
                 provider.label
@@ -115,13 +183,13 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         else {
             message = recreatingSession
                 ? ( localize(
-                2383,
+                2391,
                 "The extension '{0}' wants you to sign in again using {1}.",
                 extensionName,
                 provider.label
             ))
                 : ( localize(
-                2384,
+                2392,
                 "The extension '{0}' wants to sign in using {1}.",
                 extensionName,
                 provider.label
@@ -129,7 +197,7 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         }
         const buttons = [
             {
-                label: ( localize(2385, "&&Allow")),
+                label: ( localize(2393, "&&Allow")),
                 run() {
                     return true;
                 },
@@ -137,7 +205,7 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         ];
         if (options?.learnMore) {
             buttons.push({
-                label: ( localize(2386, "Learn more")),
+                label: ( localize(2394, "Learn more")),
                 run: async () => {
                     const result = this.loginPrompt(provider, extensionName, recreatingSession, options);
                     await this.openerService.open(URI.revive(options.learnMore), { allowCommands: true });
@@ -156,9 +224,9 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
     }
     async continueWithIncorrectAccountPrompt(chosenAccountLabel, requestedAccountLabel) {
         const result = await this.dialogService.prompt({
-            message: ( localize(2387, "Incorrect account detected")),
+            message: ( localize(2395, "Incorrect account detected")),
             detail: ( localize(
-                2388,
+                2396,
                 "The chosen account, {0}, does not match the requested account, {1}.",
                 chosenAccountLabel,
                 requestedAccountLabel
@@ -167,11 +235,11 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
             cancelButton: true,
             buttons: [
                 {
-                    label: ( localize(2389, 'Keep {0}', chosenAccountLabel)),
+                    label: ( localize(2397, 'Keep {0}', chosenAccountLabel)),
                     run: () => chosenAccountLabel
                 },
                 {
-                    label: ( localize(2390, 'Login with {0}', requestedAccountLabel)),
+                    label: ( localize(2398, 'Login with {0}', requestedAccountLabel)),
                     run: () => requestedAccountLabel
                 }
             ],
@@ -182,7 +250,8 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         return result.result === chosenAccountLabel;
     }
     async doGetSession(providerId, scopes, extensionId, extensionName, options) {
-        const sessions = await this.authenticationService.getSessions(providerId, scopes, options.account, true);
+        const authorizationServer = URI.revive(options.authorizationServer);
+        const sessions = await this.authenticationService.getSessions(providerId, scopes, { account: options.account, authorizationServer }, true);
         const provider = this.authenticationService.getProvider(providerId);
         if (options.forceNewSession && options.createIfNone) {
             throw ( new Error(
@@ -236,7 +305,11 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
             else {
                 const accountToCreate = options.account ?? matchingAccountPreferenceSession?.account;
                 do {
-                    session = await this.authenticationService.createSession(providerId, scopes, { activateImmediate: true, account: accountToCreate });
+                    session = await this.authenticationService.createSession(providerId, scopes, {
+                        activateImmediate: true,
+                        account: accountToCreate,
+                        authorizationServer
+                    });
                 } while (accountToCreate
                     && accountToCreate.label !== session.account.label
                     && !(await this.continueWithIncorrectAccountPrompt(session.account.label, accountToCreate.label)));
@@ -317,6 +390,35 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         this.authenticationExtensionsService.removeAccountPreference(extensionId, providerId);
         this.authenticationExtensionsService.removeSessionPreference(providerId, extensionId, scopes);
     }
+    async $showDeviceCodeModal(userCode, verificationUri) {
+        const { result } = await this.dialogService.prompt({
+            type: Severity.Info,
+            message: ( localize(2399, "Device Code Authentication")),
+            detail: ( localize(
+                2400,
+                "Your code: {0}\n\nTo complete authentication, navigate to {1} and enter the code above.",
+                userCode,
+                verificationUri
+            )),
+            buttons: [
+                {
+                    label: ( localize(2401, "Copy & Continue")),
+                    run: () => true
+                }
+            ],
+            cancelButton: true
+        });
+        if (result) {
+            try {
+                await this.clipboardService.writeText(userCode);
+                return await this.openerService.open(( URI.parse(verificationUri)));
+            }
+            catch (error) {
+                this.notificationService.error(( localize(2402, "Failed to open {0}", verificationUri)));
+            }
+        }
+        return false;
+    }
 };
 MainThreadAuthentication = __decorate([
     extHostNamedCustomer(MainContext.MainThreadAuthentication),
@@ -329,7 +431,10 @@ MainThreadAuthentication = __decorate([
     ( __param(7, IExtensionService)),
     ( __param(8, ITelemetryService)),
     ( __param(9, IOpenerService)),
-    ( __param(10, ILogService))
+    ( __param(10, ILogService)),
+    ( __param(11, IURLService)),
+    ( __param(12, IDynamicAuthenticationProviderStorageService)),
+    ( __param(13, IClipboardService))
 ], MainThreadAuthentication);
 
 export { MainThreadAuthentication, MainThreadAuthenticationProvider };

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

@@ -7,7 +7,7 @@ import { IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { ResourceNotebookCellEdit } from '@codingame/monaco-vscode-324f9a6e-6231-5bfc-af17-e147abd2dfd2-common/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { ResourceNotebookCellEdit } from '@codingame/monaco-vscode-4372ad43-a220-5e78-83e6-95a9cfd64384-common/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
 import { CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 

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

@@ -92,7 +92,7 @@ let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends Ex
         if (!this._extensionManifestPropertiesService.canExecuteOnWorkspace(manifest)
             && !(isWeb && this._extensionManifestPropertiesService.canExecuteOnWeb(manifest))) {
             this.logger.info(( localize(
-                2391,
+                2403,
                 "Cannot install the '{0}' extension because it is declared to not run in this setup.",
                 getExtensionId(manifest.publisher, manifest.name)
             )));

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

@@ -12,7 +12,7 @@ import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workb
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
 import { IChatRelatedFileProviderMetadata } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
 import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
-import { IChatContentInlineReference, IChatContentReference, IChatTask, IChatWarningMessage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatContentInlineReference, IChatContentReference, IChatTask, IChatTaskSerialized, IChatWarningMessage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
@@ -30,6 +30,7 @@ export declare class MainThreadChatTask implements IChatTask {
     isSettled(): boolean;
     complete(v: string | void): void;
     add(progress: IChatWarningMessage | IChatContentReference): void;
+    toJSON(): IChatTaskSerialized;
 }
 export declare class MainThreadChatAgents2 extends Disposable implements MainThreadChatAgentsShape2 {
     private readonly _chatAgentService;
@@ -48,7 +49,6 @@ export declare class MainThreadChatAgents2 extends Disposable implements MainThr
     private readonly _chatRelatedFilesProviders;
     private readonly _pendingProgress;
     private readonly _proxy;
-    private _responsePartHandlePool;
     private readonly _activeTasks;
     private readonly _unresolvedAnchors;
     constructor(extHostContext: IExtHostContext, _chatAgentService: IChatAgentService, _chatService: IChatService, _chatEditingService: IChatEditingService, _languageFeaturesService: ILanguageFeaturesService, _chatWidgetService: IChatWidgetService, _instantiationService: IInstantiationService, _logService: ILogService, _extensionService: IExtensionService, _uriIdentityService: IUriIdentityService);
@@ -56,7 +56,10 @@ export declare class MainThreadChatAgents2 extends Disposable implements MainThr
     $transferActiveChatSession(toWorkspace: UriComponents): void;
     $registerAgent(handle: number, extension: ExtensionIdentifier, id: string, metadata: IExtensionChatAgentMetadata, dynamicProps: IDynamicChatAgentProps | undefined): Promise<void>;
     $updateAgent(handle: number, metadataUpdate: IExtensionChatAgentMetadata): Promise<void>;
-    $handleProgressChunk(requestId: string, progress: IChatProgressDto, responsePartHandle?: number): Promise<number | void>;
+    $handleProgressChunk(requestId: string, chunks: (IChatProgressDto | [
+        IChatProgressDto,
+        number
+    ])[]): Promise<void>;
     $handleAnchorResolve(requestId: string, handle: string, resolveAnchor: Dto<IChatContentInlineReference> | undefined): void;
     $registerAgentCompletionsProvider(handle: number, id: string, triggerCharacters: string[]): void;
     $unregisterAgentCompletionsProvider(handle: number, id: string): void;

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

@@ -51,6 +51,13 @@ class MainThreadChatTask {
         this.progress.push(progress);
         this._onDidAddProgress.fire(progress);
     }
+    toJSON() {
+        return {
+            kind: 'progressTaskSerialized',
+            content: this.content,
+            progress: this.progress
+        };
+    }
 }
 let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     constructor(extHostContext, _chatAgentService, _chatService, _chatEditingService, _languageFeaturesService, _chatWidgetService, _instantiationService, _logService, _extensionService, _uriIdentityService) {
@@ -70,7 +77,6 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._chatParticipantDetectionProviders = this._register(( new DisposableMap()));
         this._chatRelatedFilesProviders = this._register(( new DisposableMap()));
         this._pendingProgress = ( new Map());
-        this._responsePartHandlePool = 0;
         this._activeTasks = ( new Map());
         this._unresolvedAnchors = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
@@ -141,9 +147,6 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
             provideChatTitle: (history, token) => {
                 return this._proxy.$provideChatTitle(handle, history, token);
             },
-            provideSampleQuestions: (location, token) => {
-                return this._proxy.$provideSampleQuestions(handle, location, token);
-            }
         };
         let disposable;
         if (!staticAgentRegistration && dynamicProps) {
@@ -184,49 +187,56 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         data.hasFollowups = metadataUpdate.hasFollowups;
         this._chatAgentService.updateAgent(data.id, revive(metadataUpdate));
     }
-    async $handleProgressChunk(requestId, progress, responsePartHandle) {
-        const revivedProgress = progress.kind === 'notebookEdit'
-            ? ChatNotebookEdit.fromChatEdit(revive(progress))
-            : revive(progress);
-        if (revivedProgress.kind === 'notebookEdit'
-            || revivedProgress.kind === 'textEdit'
-            || revivedProgress.kind === 'codeblockUri') {
-            revivedProgress.uri = this._uriIdentityService.asCanonicalUri(revivedProgress.uri);
-        }
-        if (revivedProgress.kind === 'progressTask') {
-            const handle = ++this._responsePartHandlePool;
-            const responsePartId = `${requestId}_${handle}`;
-            const task = ( new MainThreadChatTask(revivedProgress.content));
-            this._activeTasks.set(responsePartId, task);
-            this._pendingProgress.get(requestId)?.(task);
-            return handle;
-        }
-        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);
-                    }
-                    return responsePartHandle;
-                case 'warning':
-                case 'reference':
-                    task?.add(revivedProgress);
+    async $handleProgressChunk(requestId, chunks) {
+        const chatProgressParts = [];
+        chunks.forEach(item => {
+            const [progress, responsePartHandle] = Array.isArray(item) ? item : [item];
+            const revivedProgress = progress.kind === 'notebookEdit'
+                ? ChatNotebookEdit.fromChatEdit(revive(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') {
+                    const handle = responsePartHandle;
+                    const responsePartId = `${requestId}_${handle}`;
+                    const task = ( new MainThreadChatTask(revivedProgress.content));
+                    this._activeTasks.set(responsePartId, task);
+                    chatProgressParts.push(task);
                     return;
+                }
+                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);
+                            }
+                            return;
+                        case 'warning':
+                        case 'reference':
+                            task?.add(revivedProgress);
+                            return;
+                    }
+                }
             }
-        }
-        if (revivedProgress.kind === 'inlineReference' && revivedProgress.resolveId) {
-            if (!( this._unresolvedAnchors.has(requestId))) {
-                this._unresolvedAnchors.set(requestId, ( new Map()));
+            if (revivedProgress.kind === 'inlineReference' && revivedProgress.resolveId) {
+                if (!( this._unresolvedAnchors.has(requestId))) {
+                    this._unresolvedAnchors.set(requestId, ( new Map()));
+                }
+                this._unresolvedAnchors.get(requestId)?.set(revivedProgress.resolveId, revivedProgress);
             }
-            this._unresolvedAnchors.get(requestId)?.set(revivedProgress.resolveId, revivedProgress);
-        }
-        this._pendingProgress.get(requestId)?.(revivedProgress);
+            chatProgressParts.push(revivedProgress);
+        });
+        this._pendingProgress.get(requestId)?.(chatProgressParts);
     }
     $handleAnchorResolve(requestId, handle, resolveAnchor) {
         const anchor = this._unresolvedAnchors.get(requestId)?.get(handle);

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

@@ -10,7 +10,7 @@ import { ICommentController } from "@codingame/monaco-vscode-comments-service-ov
 import { ICommentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/comments/browser/commentService.service";
 import { CommentProviderFeatures, ExtHostCommentsShape, MainThreadCommentsShape, CommentThreadChanges } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
-import { ICellRange } from "@codingame/monaco-vscode-324f9a6e-6231-5bfc-af17-e147abd2dfd2-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { ICellRange } from "@codingame/monaco-vscode-4372ad43-a220-5e78-83e6-95a9cfd64384-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
 import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
 import { MarshalledCommentThread } from "../../common/comments.js";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
@@ -79,7 +79,7 @@ export declare class MainThreadCommentThread<T> implements languages.CommentThre
     dispose(): void;
     toJSON(): MarshalledCommentThread;
 }
-export declare class MainThreadCommentController implements ICommentController {
+export declare class MainThreadCommentController extends Disposable implements ICommentController {
     private readonly _proxy;
     private readonly _commentService;
     private readonly _handle;

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

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { DisposableStore, DisposableMap, Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { DisposableStore, Disposable, DisposableMap, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { CommentThreadCollapsibleState } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
@@ -14,7 +14,7 @@ import { COMMENTS_VIEW_ID, COMMENTS_VIEW_STORAGE_ID, COMMENTS_VIEW_TITLE } from
 import { Extensions, ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
 import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
 import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
-import { ViewPaneContainer } from '@codingame/monaco-vscode-e67a0dae-5b2c-54e6-8d61-90102c78362d-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { ViewPaneContainer } from '@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -201,7 +201,7 @@ class CommentThreadWithDisposable {
         this.disposableStore.dispose();
     }
 }
-class MainThreadCommentController {
+class MainThreadCommentController extends Disposable {
     get handle() {
         return this._handle;
     }
@@ -233,6 +233,7 @@ class MainThreadCommentController {
         return this._id;
     }
     constructor(_proxy, _commentService, _handle, _uniqueId, _id, _label, _features) {
+        super();
         this._proxy = _proxy;
         this._commentService = _commentService;
         this._handle = _handle;
@@ -240,7 +241,7 @@ class MainThreadCommentController {
         this._id = _id;
         this._label = _label;
         this._features = _features;
-        this._threads = ( new DisposableMap());
+        this._threads = this._register(( new DisposableMap()));
     }
     get activeComment() {
         return this._activeComment;
@@ -423,7 +424,7 @@ class MainThreadCommentController {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2392, 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2404, 'View icon of the comments view.')));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService, _uriIdentityService, _editorService) {
         super();
@@ -468,6 +469,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     $unregisterCommentController(handle) {
         const providerId = this._handlers.get(handle);
         this._handlers.delete(handle);
+        this._commentControllers.get(handle)?.dispose();
         this._commentControllers.delete(handle);
         if (typeof providerId !== 'string') {
             return;

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

@@ -25,7 +25,7 @@ import { ExtHostContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { CustomEditorInput } from '@codingame/monaco-vscode-7f39b6f1-3542-5430-8760-0f404d7a7cee-common/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
 import { ICustomEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/common/customEditor.service';
 import { CustomTextEditorModel } from '../../contrib/customEditor/common/customTextEditorModel.js';
-import { ExtensionKeyedWebviewOriginStore } from '@codingame/monaco-vscode-324f9a6e-6231-5bfc-af17-e147abd2dfd2-common/vscode/vs/workbench/contrib/webview/browser/webview';
+import { ExtensionKeyedWebviewOriginStore } from '@codingame/monaco-vscode-4372ad43-a220-5e78-83e6-95a9cfd64384-common/vscode/vs/workbench/contrib/webview/browser/webview';
 import { IWebviewWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service';
 import { editorGroupToColumn } from '@codingame/monaco-vscode-f48982c4-9e82-55e2-b800-20e6d1e6096f-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
@@ -34,7 +34,7 @@ import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscod
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
 import { ResourceWorkingCopy } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/resourceWorkingCopy';
-import { NO_TYPE_ID, WorkingCopyCapabilities } from '@codingame/monaco-vscode-86d65fc6-30f9-5dca-9501-e249de688591-common/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+import { NO_TYPE_ID, WorkingCopyCapabilities } from '@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy';
 import { IWorkingCopyFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { IWorkingCopyService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
@@ -302,7 +302,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2393,
+                    2405,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -370,7 +370,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2394, "Edit")),
+            label: label ?? ( localize(2406, "Edit")),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),

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

@@ -7,6 +7,8 @@ import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IDecorationsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/decorations/common/decorations.service';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 
 class DecorationRequestsQueue {
     constructor(_proxy, _handle) {
@@ -18,27 +20,27 @@ class DecorationRequestsQueue {
     }
     enqueue(uri, token) {
         const id = ++this._idPool;
-        const result = ( new Promise(resolve => {
-            this._requests.set(id, { id, uri });
-            this._resolver.set(id, resolve);
-            this._processQueue();
-        }));
+        const defer = ( new DeferredPromise());
+        this._requests.set(id, { id, uri });
+        this._resolver.set(id, defer);
+        this._processQueue();
         const sub = token.onCancellationRequested(() => {
             this._requests.delete(id);
             this._resolver.delete(id);
+            defer.error(( new CancellationError()));
         });
-        return result.finally(() => sub.dispose());
+        return defer.p.finally(() => sub.dispose());
     }
     _processQueue() {
-        if (typeof this._timer === 'number') {
+        if (this._timer !== undefined) {
             return;
         }
         this._timer = setTimeout(() => {
             const requests = this._requests;
             const resolver = this._resolver;
             this._proxy.$provideDecorations(this._handle, [...( requests.values())], CancellationToken.None).then(data => {
-                for (const [id, resolve] of resolver) {
-                    resolve(data[id]);
+                for (const [id, defer] of resolver) {
+                    defer.complete(data[id]);
                 }
             });
             this._requests = ( new Map());