@codingame/monaco-vscode-extensions-service-override 34.1.3 → 35.0.0

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

@@ -2,14 +2,17 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { DeferredPromise, AsyncIterableSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
-import { transformErrorFromSerialization, transformErrorForSerialization } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { CancellationError, transformErrorFromSerialization, transformErrorForSerialization } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { equalSets } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
-import { DisposableStore, DisposableMap, Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, DisposableMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { resizeImage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatImageUtils';
 import { ILanguageModelIgnoredFilesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/ignoredFiles.service';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
@@ -22,11 +25,27 @@ import { SerializableObjectWithBuffers } from '@codingame/monaco-vscode-api/vsco
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { LanguageModelError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHostTypes';
 
+class RequestCancellationTokenSource extends Disposable {
+    constructor(parent, onCancellationRequested) {
+        super();
+        this._source = this._register(( new CancellationTokenSource(parent)));
+        if (onCancellationRequested) {
+            this._register(this._source.token.onCancellationRequested(onCancellationRequested));
+        }
+    }
+    get token() {
+        return this._source.token;
+    }
+    cancel() {
+        this._source.cancel();
+    }
+}
 let MainThreadLanguageModels = class MainThreadLanguageModels {
     constructor(
         extHostContext,
         _chatProviderService,
         _logService,
+        _productService,
         _authenticationService,
         _authenticationAccessService,
         _extensionService,
@@ -34,6 +53,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
     ) {
         this._chatProviderService = _chatProviderService;
         this._logService = _logService;
+        this._productService = _productService;
         this._authenticationService = _authenticationService;
         this._authenticationAccessService = _authenticationAccessService;
         this._extensionService = _extensionService;
@@ -42,6 +62,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         this._providerRegistrations = ( new DisposableMap());
         this._lmProviderChange = ( new Emitter());
         this._pendingProgress = ( new Map());
+        this._pendingCancelCTS = ( new DisposableMap());
         this._ignoredFileProviderRegistrations = ( new DisposableMap());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatProvider));
         let lastModelIds = ( new Set(this._chatProviderService.getLanguageModelIds()));
@@ -57,6 +78,8 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
     dispose() {
         this._lmProviderChange.dispose();
         this._providerRegistrations.dispose();
+        this._pendingProgress.clear();
+        this._pendingCancelCTS.dispose();
         this._ignoredFileProviderRegistrations.dispose();
         this._store.dispose();
     }
@@ -67,30 +90,58 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
                 onDidChange: Event.filter(this._lmProviderChange.event, e => e.vendor === vendor, disposables),
                 provideLanguageModelChatInfo: async (options, token) => {
                     const modelsAndIdentifiers = await this._proxy.$provideLanguageModelChatInfo(vendor, options, token);
-                    modelsAndIdentifiers.forEach(m => {
+                    const copilotExtensionId = this._productService.defaultChatAgent?.chatExtensionId;
+                    return ( modelsAndIdentifiers.map(m => {
                         if (m.metadata.auth) {
                             disposables.add(
                                 this._registerAuthenticationProvider(m.metadata.extension, m.metadata.auth)
                             );
                         }
-                    });
-                    return modelsAndIdentifiers;
+                        if (m.metadata.isBYOK !== undefined) {
+                            return m;
+                        }
+                        const isBuiltinCopilot = !!copilotExtensionId && ExtensionIdentifier.equals(m.metadata.extension, copilotExtensionId);
+                        return {
+                            ...m,
+                            metadata: {
+                                ...m.metadata,
+                                isBYOK: !isBuiltinCopilot
+                            }
+                        };
+                    }));
                 },
                 sendChatRequest: async (modelId, messages, from, options, token) => {
                     const requestId = (Math.random() * 1e6) | 0;
                     const defer = ( new DeferredPromise());
+                    defer.p.catch(() => {});
                     const stream = new AsyncIterableSource();
                     try {
                         this._pendingProgress.set(requestId, {
                             defer,
                             stream
                         });
+                        const cts = ( new RequestCancellationTokenSource(token, () => {
+                            this._proxy.$cancelLanguageModelChatRequest(requestId);
+                        }));
+                        this._pendingCancelCTS.set(requestId, cts);
                         await Promise.all(( messages.flatMap(msg => msg.content).filter(part => part.type === "image_url").map(async part => {
                             part.value.data = VSBuffer.wrap(await resizeImage(part.value.data.buffer));
                         })));
-                        await this._proxy.$startChatRequest(modelId, requestId, from, ( new SerializableObjectWithBuffers(messages)), options, token);
+                        if (token.isCancellationRequested) {
+                            this._pendingProgress.delete(requestId);
+                            this._pendingCancelCTS.deleteAndDispose(requestId);
+                            const err = ( new CancellationError());
+                            stream.reject(err);
+                            defer.error(err);
+                            return {
+                                result: defer.p,
+                                stream: stream.asyncIterable
+                            };
+                        }
+                        await this._proxy.$startChatRequest(modelId, requestId, from, ( new SerializableObjectWithBuffers(messages)), options, cts.token);
                     } catch (err) {
                         this._pendingProgress.delete(requestId);
+                        this._pendingCancelCTS.deleteAndDispose(requestId);
                         throw err;
                     }
                     return {
@@ -125,6 +176,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         this._logService.trace("[LM] report response DONE", Boolean(data), requestId, err);
         if (data) {
             this._pendingProgress.delete(requestId);
+            this._pendingCancelCTS.deleteAndDispose(requestId);
             if (err) {
                 const error = LanguageModelError.tryDeserialize(err) ?? transformErrorFromSerialization(err);
                 data.stream.reject(error);
@@ -138,16 +190,22 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
     $unregisterProvider(vendor) {
         this._providerRegistrations.deleteAndDispose(vendor);
     }
+    $cancelLanguageModelChatRequest(requestId) {
+        this._pendingCancelCTS.get(requestId)?.cancel();
+    }
     $selectChatModels(selector) {
         return this._chatProviderService.selectLanguageModels(selector);
     }
     async $tryStartChatRequest(extension, modelIdentifier, requestId, messages, options, token) {
         this._logService.trace("[CHAT] request STARTED", extension.value, requestId);
+        const cts = ( new RequestCancellationTokenSource(token));
+        this._pendingCancelCTS.set(requestId, cts);
         let response;
         try {
-            response = await this._chatProviderService.sendChatRequest(modelIdentifier, extension, messages.value, options, token);
+            response = await this._chatProviderService.sendChatRequest(modelIdentifier, extension, messages.value, options, cts.token);
         } catch (err) {
             this._logService.error("[CHAT] request FAILED", extension.value, requestId, err);
+            this._pendingCancelCTS.deleteAndDispose(requestId);
             throw err;
         }
         const streaming = (async () => {
@@ -169,6 +227,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         })();
         Promise.allSettled([response.result, streaming]).then(() => {
             this._logService.debug("[CHAT] extension request DONE", extension.value, requestId);
+            this._pendingCancelCTS.deleteAndDispose(requestId);
             this._proxy.$acceptResponseDone(requestId, undefined);
         }, err => {
             this._logService.error(
@@ -177,6 +236,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
                 extension.value,
                 requestId
             );
+            this._pendingCancelCTS.deleteAndDispose(requestId);
             this._proxy.$acceptResponseDone(requestId, transformErrorForSerialization(err));
         });
     }
@@ -188,7 +248,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         if (this._authenticationService.getProviderIds().includes(authProviderId)) {
             return Disposable.None;
         }
-        const accountLabel = auth.accountLabel ?? ( localize(2697, "Language Models"));
+        const accountLabel = auth.accountLabel ?? ( localize(2773, "Language Models"));
         const disposables = ( new DisposableStore());
         const provider = ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel));
         this._authenticationService.registerAuthenticationProvider(authProviderId, provider);
@@ -228,7 +288,7 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
     }
 };
 MainThreadLanguageModels = __decorate(
-    [extHostNamedCustomer(MainContext.MainThreadLanguageModels), ( __param(1, ILanguageModelsService)), ( __param(2, ILogService)), ( __param(3, IAuthenticationService)), ( __param(4, IAuthenticationAccessService)), ( __param(5, IExtensionService)), ( __param(6, ILanguageModelIgnoredFilesService))],
+    [extHostNamedCustomer(MainContext.MainThreadLanguageModels), ( __param(1, ILanguageModelsService)), ( __param(2, ILogService)), ( __param(3, IProductService)), ( __param(4, IAuthenticationService)), ( __param(5, IAuthenticationAccessService)), ( __param(6, IExtensionService)), ( __param(7, ILanguageModelIgnoredFilesService))],
     MainThreadLanguageModels
 );
 class LanguageModelAccessAuthProvider {
@@ -271,7 +331,7 @@ class LanguageModelAccessAuthProvider {
     }
     confirmation(extensionName, _recreatingSession) {
         return localize(
-            2698,
+            2774,
             "The extension '{0}' wants to access the language models provided by {1}.",
             extensionName,
             this.label

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

@@ -1,7 +1,7 @@
 import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
 import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
-import { MainThreadLanguagesShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { MainThreadLanguagesShape, ISyntaxHighlightingResultDto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { IPosition } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
 import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
@@ -10,19 +10,23 @@ import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor
 import { ILanguageStatus } from "@codingame/monaco-vscode-languages-service-override/vscode/vs/workbench/services/languageStatus/common/languageStatusService";
 import { ILanguageStatusService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/languageStatus/common/languageStatusService.service";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITextMateTokenizationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeature.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
 export declare class MainThreadLanguages extends Disposable implements MainThreadLanguagesShape {
     private readonly _languageService;
     private readonly _modelService;
     private _resolverService;
     private readonly _languageStatusService;
+    private readonly _textMateService;
     private readonly _proxy;
     private readonly _status;
-    constructor(_extHostContext: IExtHostContext, _languageService: ILanguageService, _modelService: IModelService, _resolverService: ITextModelService, _languageStatusService: ILanguageStatusService);
+    constructor(_extHostContext: IExtHostContext, _languageService: ILanguageService, _modelService: IModelService, _resolverService: ITextModelService, _languageStatusService: ILanguageStatusService, _textMateService: ITextMateTokenizationService, themeService: IThemeService);
     $changeLanguage(resource: UriComponents, languageId: string): Promise<void>;
     $tokensAtPosition(resource: UriComponents, position: IPosition): Promise<undefined | {
         type: StandardTokenType;
         range: IRange;
     }>;
+    $computeFullSyntaxHighlighting(source: string, languageId: string): Promise<ISyntaxHighlightingResultDto>;
     $setLanguageStatus(handle: number, status: ILanguageStatus): void;
     $removeLanguageStatus(handle: number): void;
 }

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

@@ -6,9 +6,14 @@ import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/com
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { FontStyle, TokenMetadata } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/encodedTokenAttributes';
+import { TokenizationRegistry } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { Color } from '@codingame/monaco-vscode-api/vscode/vs/base/common/color';
 import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
 import { ILanguageStatusService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/languageStatus/common/languageStatusService.service';
 import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ITextMateTokenizationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeature.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
 
 let MainThreadLanguages = class MainThreadLanguages extends Disposable {
     constructor(
@@ -16,19 +21,25 @@ let MainThreadLanguages = class MainThreadLanguages extends Disposable {
         _languageService,
         _modelService,
         _resolverService,
-        _languageStatusService
+        _languageStatusService,
+        _textMateService,
+        themeService
     ) {
         super();
         this._languageService = _languageService;
         this._modelService = _modelService;
         this._resolverService = _resolverService;
         this._languageStatusService = _languageStatusService;
+        this._textMateService = _textMateService;
         this._status = this._register(( new DisposableMap()));
         this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostLanguages));
         this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
         this._register(_languageService.onDidChange(_ => {
             this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
         }));
+        this._register(themeService.onDidColorThemeChange(() => {
+            this._proxy.$acceptSyntaxHighlightingThemeChanged();
+        }));
     }
     async $changeLanguage(resource, languageId) {
         if (!this._languageService.isRegisteredLanguageId(languageId)) {
@@ -61,6 +72,54 @@ let MainThreadLanguages = class MainThreadLanguages extends Disposable {
             ))
         };
     }
+    async $computeFullSyntaxHighlighting(source, languageId) {
+        const colorMap = ( (TokenizationRegistry.getColorMap() ?? []).map(c => c ? Color.Format.CSS.formatHexA(c) : ""));
+        const resolvedLanguageId = this._languageService.isRegisteredLanguageId(languageId) ? languageId : this._languageService.getLanguageIdByLanguageName(languageId);
+        const grammar = resolvedLanguageId ? await this._textMateService.createTokenizer(resolvedLanguageId) : null;
+        if (!grammar) {
+            const tokens = source.length === 0 ? [] : [{
+                length: source.length,
+                foreground: 0,
+                fontStyle: FontStyle.None
+            }];
+            return {
+                tokens,
+                colorMap
+            };
+        }
+        const tokens = [];
+        const lines = source.split("\n");
+        let state = null;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const result = grammar.tokenizeLine2(line, state, 500);
+            state = result.ruleStack;
+            const binary = result.tokens;
+            for (let j = 0; j < binary.length; j += 2) {
+                const startOffset = binary[j];
+                const metadata = binary[j + 1];
+                const endOffset = j + 2 < binary.length ? binary[j + 2] : line.length;
+                if (endOffset > startOffset) {
+                    tokens.push({
+                        length: endOffset - startOffset,
+                        foreground: TokenMetadata.getForeground(metadata),
+                        fontStyle: TokenMetadata.getFontStyle(metadata)
+                    });
+                }
+            }
+            if (i < lines.length - 1) {
+                tokens.push({
+                    length: 1,
+                    foreground: 0,
+                    fontStyle: FontStyle.None
+                });
+            }
+        }
+        return {
+            tokens,
+            colorMap
+        };
+    }
     $setLanguageStatus(handle, status) {
         this._status.set(handle, this._languageStatusService.addStatus(status));
     }
@@ -68,6 +127,6 @@ let MainThreadLanguages = class MainThreadLanguages extends Disposable {
         this._status.deleteAndDispose(handle);
     }
 };
-MainThreadLanguages = __decorate([extHostNamedCustomer(MainContext.MainThreadLanguages), ( __param(1, ILanguageService)), ( __param(2, IModelService)), ( __param(3, ITextModelService)), ( __param(4, ILanguageStatusService))], MainThreadLanguages);
+MainThreadLanguages = __decorate([extHostNamedCustomer(MainContext.MainThreadLanguages), ( __param(1, ILanguageService)), ( __param(2, IModelService)), ( __param(3, ITextModelService)), ( __param(4, ILanguageStatusService)), ( __param(5, ITextMateTokenizationService)), ( __param(6, IThemeService))], MainThreadLanguages);
 
 export { MainThreadLanguages };

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

@@ -246,7 +246,7 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             const resource = authDetails.resourceMetadata?.resource;
             if (!resource) {
                 throw ( new Error(( localize(
-                    2699,
+                    2775,
                     "The enterprise-managed MCP server '{0}' did not advertise a protected-resource metadata document with a 'resource' identifier.",
                     server.label
                 ))));
@@ -255,7 +255,7 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             const audience = resourceAuthServers[0];
             if (!audience) {
                 throw ( new Error(( localize(
-                    2700,
+                    2776,
                     "The enterprise-managed MCP server '{0}' did not advertise an `authorization_servers` entry in its protected-resource metadata.",
                     server.label
                 ))));
@@ -342,7 +342,7 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
         const configuredIssuer = config.issuer?.trim();
         if (!configuredIssuer) {
             throw ( new Error(( localize(
-                2701,
+                2777,
                 "Enterprise-managed MCP authentication requires `mcp.enterpriseManagedAuth.idp.issuer` to be configured. Set it via enterprise policy (Windows Group Policy / macOS managed preferences / Linux `/etc/vscode/policy.json`) or, for local testing, by hand-editing `settings.json`."
             ))));
         }
@@ -351,14 +351,14 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             parsed = ( URI.parse(configuredIssuer));
         } catch {
             throw ( new Error(( localize(
-                2702,
+                2778,
                 "Enterprise-managed MCP authentication requires `mcp.enterpriseManagedAuth.idp.issuer` to be a valid URL; got '{0}'.",
                 configuredIssuer
             ))));
         }
         if (parsed.scheme !== "https" && parsed.scheme !== "http") {
             throw ( new Error(( localize(
-                2703,
+                2779,
                 "Enterprise-managed MCP authentication requires `mcp.enterpriseManagedAuth.idp.issuer` to use the `https` or `http` scheme; got '{0}'.",
                 configuredIssuer
             ))));
@@ -460,9 +460,9 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
     }
     async continueWithIncorrectAccountPrompt(chosenAccountLabel, requestedAccountLabel) {
         const result = await this.dialogService.prompt({
-            message: ( localize(2704, "Incorrect account detected")),
+            message: ( localize(2780, "Incorrect account detected")),
             detail: ( localize(
-                2705,
+                2781,
                 "The chosen account, {0}, does not match the requested account, {1}.",
                 chosenAccountLabel,
                 requestedAccountLabel
@@ -470,10 +470,10 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             type: Severity.Warning,
             cancelButton: true,
             buttons: [{
-                label: ( localize(2706, "Keep {0}", chosenAccountLabel)),
+                label: ( localize(2782, "Keep {0}", chosenAccountLabel)),
                 run: () => chosenAccountLabel
             }, {
-                label: ( localize(2707, "Login with {0}", requestedAccountLabel)),
+                label: ( localize(2783, "Login with {0}", requestedAccountLabel)),
                 run: () => requestedAccountLabel
             }]
         });
@@ -505,7 +505,7 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
             } catch (e) {
                 if (UserInteractionRequiredError.is(e)) {
                     server.pushLog(LogLevel.Warning, ( localize(
-                        2708,
+                        2784,
                         "Authentication session for {0} removed, stopping server",
                         providerLabel
                     )));
@@ -552,18 +552,18 @@ let MainThreadMcp = class MainThreadMcp extends Disposable {
     }
     async loginPrompt(mcpLabel, providerLabel, recreatingSession) {
         const message = recreatingSession ? ( localize(
-            2709,
+            2785,
             "The MCP Server Definition '{0}' wants you to authenticate to {1}.",
             mcpLabel,
             providerLabel
         )) : ( localize(
-            2710,
+            2786,
             "The MCP Server Definition '{0}' wants to authenticate to {1}.",
             mcpLabel,
             providerLabel
         ));
         const buttons = [{
-            label: ( localize(2711, "&&Allow")),
+            label: ( localize(2787, "&&Allow")),
             run() {
                 return true;
             }

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

@@ -66,13 +66,13 @@ let MainThreadMessageService = class MainThreadMessageService {
                 sourceIsUrgent = MainThreadMessageService_1.URGENT_NOTIFICATION_SOURCES.includes(source.id);
             }
             if (!source) {
-                source = ( localize(2712, "Extension"));
+                source = ( localize(2788, "Extension"));
             }
             const secondaryActions = [];
             if (options.source) {
                 secondaryActions.push(toAction({
                     id: options.source.identifier.value,
-                    label: ( localize(2713, "Manage Extension")),
+                    label: ( localize(2789, "Manage Extension")),
                     run: () => {
                         return this._commandService.executeCommand("_extensions.manage", options.source.identifier.value);
                     }
@@ -111,12 +111,12 @@ let MainThreadMessageService = class MainThreadMessageService {
         if (!cancelButton) {
             if (buttons.length > 0) {
                 cancelButton = {
-                    label: ( localize(2714, "Cancel")),
+                    label: ( localize(2790, "Cancel")),
                     run: () => undefined
                 };
             } else {
                 cancelButton = {
-                    label: ( localize(2715, "&&OK")),
+                    label: ( localize(2791, "&&OK")),
                     run: () => undefined
                 };
             }

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

@@ -18,7 +18,7 @@ class ExtHostNotebookDocumentSaveParticipant {
         }
         let _warningTimeout;
         const p = ( new Promise((resolve, reject) => {
-            _warningTimeout = setTimeout(() => reject(( new Error(( localize(2716, "Aborted onWillSaveNotebookDocument-event after 1750ms"))))), 1750);
+            _warningTimeout = setTimeout(() => reject(( new Error(( localize(2792, "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/mainThreadOutputService.js

@@ -94,11 +94,11 @@ let MainThreadOutputService = class MainThreadOutputService extends Disposable {
     }
     _showChannelQuietly(channel) {
         const statusProperties = {
-            name: ( localize(2717, "Show Output")),
+            name: ( localize(2793, "Show Output")),
             text: "$(output)",
-            ariaLabel: ( localize(2718, "Show {0} Output Channel", channel.label)),
+            ariaLabel: ( localize(2794, "Show {0} Output Channel", channel.label)),
             command: `workbench.action.output.show.${channel.id}`,
-            tooltip: ( localize(2719, "Show {0} Output Channel", channel.label)),
+            tooltip: ( localize(2795, "Show {0} Output Channel", channel.label)),
             kind: "prominent"
         };
         if (!this._outputStatusItem.value) {

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

@@ -38,7 +38,7 @@ let MainThreadProgress = class MainThreadProgress {
                 location: ProgressLocation.Notification,
                 secondaryActions: [toAction({
                     id: extensionId,
-                    label: ( localize(2720, "Manage Extension")),
+                    label: ( localize(2796, "Manage Extension")),
                     run: () => this._commandService.executeCommand("_extensions.manage", extensionId)
                 })]
             };

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

@@ -1,13 +1,19 @@
 import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IDocumentFilterDto, MainThreadQuickDiffShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IQuickDiffService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff.service";
+import { IQuickDiffModelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/quickDiffModel.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 export declare class MainThreadQuickDiff implements MainThreadQuickDiffShape {
     private readonly quickDiffService;
+    private readonly quickDiffModelService;
     private readonly proxy;
     private providerDisposables;
-    constructor(extHostContext: IExtHostContext, quickDiffService: IQuickDiffService);
+    private informationDisposables;
+    constructor(extHostContext: IExtHostContext, quickDiffService: IQuickDiffService, quickDiffModelService: IQuickDiffModelService);
     $registerQuickDiffProvider(handle: number, selector: IDocumentFilterDto[], id: string, label: string, rootUri: UriComponents | undefined): Promise<void>;
     $unregisterQuickDiffProvider(handle: number): Promise<void>;
+    $createSourceControlDiffInformation(handle: number, uri: UriComponents): Promise<void>;
+    $disposeSourceControlDiffInformation(handle: number): Promise<void>;
+    private sendSourceControlDiffInformation;
     dispose(): void;
 }

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

@@ -1,16 +1,19 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { IQuickDiffService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff.service';
+import { IQuickDiffModelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/browser/quickDiffModel.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 
 let MainThreadQuickDiff = class MainThreadQuickDiff {
-    constructor(extHostContext, quickDiffService) {
+    constructor(extHostContext, quickDiffService, quickDiffModelService) {
         this.quickDiffService = quickDiffService;
+        this.quickDiffModelService = quickDiffModelService;
         this.providerDisposables = ( new DisposableMap());
+        this.informationDisposables = ( new DisposableMap());
         this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostQuickDiff));
     }
     async $registerQuickDiffProvider(handle, selector, id, label, rootUri) {
@@ -34,10 +37,50 @@ let MainThreadQuickDiff = class MainThreadQuickDiff {
             this.providerDisposables.deleteAndDispose(handle);
         }
     }
+    async $createSourceControlDiffInformation(handle, uri) {
+        const reference = this.quickDiffModelService.createQuickDiffModelReference(URI.revive(uri));
+        if (!reference) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        store.add(reference);
+        store.add(
+            reference.object.onDidChange(() => this.sendSourceControlDiffInformation(handle, reference))
+        );
+        this.informationDisposables.set(handle, store);
+        this.sendSourceControlDiffInformation(handle, reference);
+    }
+    async $disposeSourceControlDiffInformation(handle) {
+        if (( this.informationDisposables.has(handle))) {
+            this.informationDisposables.deleteAndDispose(handle);
+        }
+    }
+    sendSourceControlDiffInformation(handle, reference) {
+        const model = reference.object;
+        const primaryResult = model.getQuickDiffResults().find(result => result.providerKind === "primary");
+        if (!primaryResult) {
+            this.proxy.$acceptSourceControlDiffInformation(handle, undefined);
+            return;
+        }
+        const changes = ( primaryResult.changes2.map(change => [
+            change.original.startLineNumber,
+            change.original.endLineNumberExclusive,
+            change.modified.startLineNumber,
+            change.modified.endLineNumberExclusive
+        ]));
+        const diffInformation = {
+            documentVersion: model.changesVersionId,
+            original: primaryResult.original,
+            modified: primaryResult.modified,
+            changes
+        };
+        this.proxy.$acceptSourceControlDiffInformation(handle, diffInformation);
+    }
     dispose() {
         this.providerDisposables.dispose();
+        this.informationDisposables.dispose();
     }
 };
-MainThreadQuickDiff = __decorate([extHostNamedCustomer(MainContext.MainThreadQuickDiff), ( __param(1, IQuickDiffService))], MainThreadQuickDiff);
+MainThreadQuickDiff = __decorate([extHostNamedCustomer(MainContext.MainThreadQuickDiff), ( __param(1, IQuickDiffService)), ( __param(2, IQuickDiffModelService))], MainThreadQuickDiff);
 
 export { MainThreadQuickDiff };

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

@@ -17,7 +17,7 @@ class ExtHostSaveParticipant {
             return undefined;
         }
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(2721, "Aborted onWillSaveTextDocument-event after 1750ms"))))), 1750);
+            setTimeout(() => reject(( new Error(( localize(2797, "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

@@ -397,7 +397,7 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( localize(2722, "{0}: {1}", source.label, task.name));
+        const label = ( localize(2798, "{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 ContributedTask(