@codingame/monaco-vscode-api 18.4.0 → 19.0.1

package/vscode/src/vs/workbench/api/common/extHostAuthentication.js

@@ -9,10 +9,10 @@ import { INTERNAL_AUTH_PROVIDER_PREFIX } from '../../services/authentication/com
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { URI } from '../../../base/common/uri.js';
-import { fetchDynamicRegistration, isAuthorizationTokenResponse, getClaimsFromJWT } from '../../../base/common/oauth.js';
+import { fetchDynamicRegistration, isAuthorizationTokenResponse, isAuthorizationErrorResponse, AuthorizationErrorType, getClaimsFromJWT } from '../../../base/common/oauth.js';
 import { IExtHostWindow } from './extHostWindow.js';
 import { IExtHostInitDataService } from './extHostInitDataService.js';
-import { ILoggerService } from '../../../platform/log/common/log.service.js';
+import { ILoggerService, ILogService } from '../../../platform/log/common/log.service.js';
 import '../../../base/common/observableInternal/index.js';
 import { stringHash } from '../../../base/common/hash.js';
 import { DisposableStore } from '../../../base/common/lifecycle.js';
@@ -21,21 +21,23 @@ import { encodeBase64, VSBuffer } from '../../../base/common/buffer.js';
 import { equals } from '../../../base/common/arrays.js';
 import { IExtHostProgress } from './extHostProgress.js';
 import { isCancellationError, CancellationError } from '../../../base/common/errors.js';
-import { raceCancellationError } from '../../../base/common/async.js';
+import { SequencerByKey, raceCancellationError } from '../../../base/common/async.js';
 import { observableValue } from '../../../base/common/observableInternal/observables/observableValue.js';
 import { derivedOpts } from '../../../base/common/observableInternal/observables/derived.js';
 import { autorun } from '../../../base/common/observableInternal/reactions/autorun.js';
 
 const IExtHostAuthentication = ( createDecorator('IExtHostAuthentication'));
 let ExtHostAuthentication = class ExtHostAuthentication {
-    constructor(extHostRpc, _initData, _extHostWindow, _extHostUrls, _extHostProgress, _extHostLoggerService) {
+    constructor(extHostRpc, _initData, _extHostWindow, _extHostUrls, _extHostProgress, _extHostLoggerService, _logService) {
         this._initData = _initData;
         this._extHostWindow = _extHostWindow;
         this._extHostUrls = _extHostUrls;
         this._extHostProgress = _extHostProgress;
         this._extHostLoggerService = _extHostLoggerService;
+        this._logService = _logService;
         this._dynamicAuthProviderCtor = DynamicAuthProvider;
         this._authenticationProviders = ( new Map());
+        this._providerOperations = ( new SequencerByKey());
         this._onDidChangeSessions = ( new Emitter());
         this._getSessionTaskSingler = ( new TaskSingler());
         this._onDidDynamicAuthProviderTokensChange = ( new Emitter());
@@ -62,48 +64,55 @@ let ExtHostAuthentication = class ExtHostAuthentication {
         await this._proxy.$ensureProvider(providerId);
         return await this._proxy.$getAccounts(providerId);
     }
-    async removeSession(providerId, sessionId) {
-        const providerData = this._authenticationProviders.get(providerId);
-        if (!providerData) {
-            return this._proxy.$removeSession(providerId, sessionId);
-        }
-        return providerData.provider.removeSession(sessionId);
-    }
     registerAuthenticationProvider(id, label, provider, options) {
-        if (this._authenticationProviders.get(id)) {
-            throw ( new Error(`An authentication provider with id '${id}' is already registered.`));
-        }
-        this._authenticationProviders.set(id, { label, provider, options: options ?? { supportsMultipleAccounts: false } });
-        const listener = provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(id, e));
-        this._proxy.$registerAuthenticationProvider(id, label, options?.supportsMultipleAccounts ?? false, options?.supportedAuthorizationServers);
+        void this._providerOperations.queue(id, async () => {
+            if (this._authenticationProviders.get(id)) {
+                this._logService.error(`An authentication provider with id '${id}' is already registered. The existing provider will not be replaced.`);
+                return;
+            }
+            const listener = provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(id, e));
+            this._authenticationProviders.set(id, { label, provider, disposable: listener, options: options ?? { supportsMultipleAccounts: false } });
+            await this._proxy.$registerAuthenticationProvider(id, label, options?.supportsMultipleAccounts ?? false, options?.supportedAuthorizationServers);
+        });
         return ( new Disposable(() => {
-            listener.dispose();
-            this._authenticationProviders.delete(id);
-            this._proxy.$unregisterAuthenticationProvider(id);
+            void this._providerOperations.queue(id, async () => {
+                const providerData = this._authenticationProviders.get(id);
+                if (providerData) {
+                    providerData.disposable?.dispose();
+                    this._authenticationProviders.delete(id);
+                    await this._proxy.$unregisterAuthenticationProvider(id);
+                }
+            });
         }));
     }
-    async $createSession(providerId, scopes, options) {
-        const providerData = this._authenticationProviders.get(providerId);
-        if (providerData) {
-            options.authorizationServer = URI.revive(options.authorizationServer);
-            return await providerData.provider.createSession(scopes, options);
-        }
-        throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
+    $createSession(providerId, scopes, options) {
+        return this._providerOperations.queue(providerId, async () => {
+            const providerData = this._authenticationProviders.get(providerId);
+            if (providerData) {
+                options.authorizationServer = URI.revive(options.authorizationServer);
+                return await providerData.provider.createSession(scopes, options);
+            }
+            throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
+        });
     }
-    async $removeSession(providerId, sessionId) {
-        const providerData = this._authenticationProviders.get(providerId);
-        if (providerData) {
-            return await providerData.provider.removeSession(sessionId);
-        }
-        throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
+    $removeSession(providerId, sessionId) {
+        return this._providerOperations.queue(providerId, async () => {
+            const providerData = this._authenticationProviders.get(providerId);
+            if (providerData) {
+                return await providerData.provider.removeSession(sessionId);
+            }
+            throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
+        });
     }
-    async $getSessions(providerId, scopes, options) {
-        const providerData = this._authenticationProviders.get(providerId);
-        if (providerData) {
-            options.authorizationServer = URI.revive(options.authorizationServer);
-            return await providerData.provider.getSessions(scopes, options);
-        }
-        throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
+    $getSessions(providerId, scopes, options) {
+        return this._providerOperations.queue(providerId, async () => {
+            const providerData = this._authenticationProviders.get(providerId);
+            if (providerData) {
+                options.authorizationServer = URI.revive(options.authorizationServer);
+                return await providerData.provider.getSessions(scopes, options);
+            }
+            throw ( new Error(`Unable to find authentication provider with handle: ${providerId}`));
+        });
     }
     $onDidChangeAuthenticationSessions(id, label, extensionIdFilter) {
         if (!id.startsWith(INTERNAL_AUTH_PROVIDER_PREFIX)) {
@@ -112,20 +121,18 @@ let ExtHostAuthentication = class ExtHostAuthentication {
         return Promise.resolve();
     }
     $onDidUnregisterAuthenticationProvider(id) {
-        const providerData = this._authenticationProviders.get(id);
-        if (providerData?.disposable) {
-            providerData.disposable.dispose();
-            this._authenticationProviders.delete(id);
-        }
-        return Promise.resolve();
+        return this._providerOperations.queue(id, async () => {
+            const providerData = this._authenticationProviders.get(id);
+            if (providerData) {
+                providerData.disposable?.dispose();
+                this._authenticationProviders.delete(id);
+            }
+        });
     }
     async $registerDynamicAuthProvider(authorizationServerComponents, serverMetadata, resourceMetadata, clientId, initialTokens) {
         if (!clientId) {
-            if (!serverMetadata.registration_endpoint) {
-                throw ( new Error('Server does not support dynamic registration'));
-            }
             try {
-                const registration = await fetchDynamicRegistration(serverMetadata.registration_endpoint, this._initData.environment.appName);
+                const registration = await fetchDynamicRegistration(serverMetadata, this._initData.environment.appName, resourceMetadata?.scopes_supported);
                 clientId = registration.client_id;
             }
             catch (err) {
@@ -133,14 +140,18 @@ let ExtHostAuthentication = class ExtHostAuthentication {
             }
         }
         const provider = new this._dynamicAuthProviderCtor(this._extHostWindow, this._extHostUrls, this._initData, this._extHostProgress, this._extHostLoggerService, this._proxy, URI.revive(authorizationServerComponents), serverMetadata, resourceMetadata, clientId, this._onDidDynamicAuthProviderTokensChange, initialTokens || []);
-        const disposable = provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(provider.id, e));
-        this._authenticationProviders.set(provider.id, {
-            label: provider.label,
-            provider,
-            disposable: Disposable.from(provider, disposable),
-            options: { supportsMultipleAccounts: false }
+        await this._providerOperations.queue(provider.id, async () => {
+            this._authenticationProviders.set(provider.id, {
+                label: provider.label,
+                provider,
+                disposable: Disposable.from(provider, provider.onDidChangeSessions(e => this._proxy.$sendDidChangeSessions(provider.id, e)), provider.onDidChangeClientId(() => this._proxy.$sendDidChangeDynamicProviderInfo({
+                    providerId: provider.id,
+                    clientId: provider.clientId
+                }))),
+                options: { supportsMultipleAccounts: false }
+            });
+            await this._proxy.$registerDynamicAuthenticationProvider(provider.id, provider.label, provider.authorizationServer, provider.clientId);
         });
-        await this._proxy.$registerDynamicAuthenticationProvider(provider.id, provider.label, provider.authorizationServer, provider.clientId);
         return provider.id;
     }
     async $onDidChangeDynamicAuthProviderTokens(authProviderId, clientId, tokens) {
@@ -153,7 +164,8 @@ ExtHostAuthentication = ( __decorate([
     ( __param(2, IExtHostWindow)),
     ( __param(3, IExtHostUrlsService)),
     ( __param(4, IExtHostProgress)),
-    ( __param(5, ILoggerService))
+    ( __param(5, ILoggerService)),
+    ( __param(6, ILogService))
 ], ExtHostAuthentication));
 class TaskSingler {
     constructor() {
@@ -170,7 +182,7 @@ class TaskSingler {
     }
 }
 let DynamicAuthProvider = class DynamicAuthProvider {
-    constructor(_extHostWindow, _extHostUrls, _initData, _extHostProgress, loggerService, _proxy, authorizationServer, _serverMetadata, _resourceMetadata, clientId, onDidDynamicAuthProviderTokensChange, initialTokens) {
+    constructor(_extHostWindow, _extHostUrls, _initData, _extHostProgress, loggerService, _proxy, authorizationServer, _serverMetadata, _resourceMetadata, _clientId, onDidDynamicAuthProviderTokensChange, initialTokens) {
         this._extHostWindow = _extHostWindow;
         this._extHostUrls = _extHostUrls;
         this._initData = _initData;
@@ -179,30 +191,35 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         this.authorizationServer = authorizationServer;
         this._serverMetadata = _serverMetadata;
         this._resourceMetadata = _resourceMetadata;
-        this.clientId = clientId;
+        this._clientId = _clientId;
         this._onDidChangeSessions = ( new Emitter());
         this.onDidChangeSessions = this._onDidChangeSessions.event;
+        this._onDidChangeClientId = ( new Emitter());
+        this.onDidChangeClientId = this._onDidChangeClientId.event;
         const stringifiedServer = ( authorizationServer.toString(true));
         this.id = _resourceMetadata?.resource
             ? stringifiedServer + ' ' + _resourceMetadata?.resource
             : stringifiedServer;
         this.label = _resourceMetadata?.resource_name ?? this.authorizationServer.authority;
-        this._logger = loggerService.createLogger(stringifiedServer, { name: this.label });
+        this._logger = loggerService.createLogger(this.id, { name: this.label });
         this._disposable = ( new DisposableStore());
         this._disposable.add(this._onDidChangeSessions);
         const scopedEvent = Event.chain(onDidDynamicAuthProviderTokensChange.event, $ => ( $
-            .filter(e => e.authProviderId === this.id && e.clientId === clientId)
+            .filter(e => e.authProviderId === this.id && e.clientId === _clientId)
             .map(e => e.tokens)));
         this._tokenStore = this._disposable.add(( new TokenStore({
             onDidChange: scopedEvent,
-            set: (tokens) => _proxy.$setSessionsForDynamicAuthProvider(stringifiedServer, this.clientId, tokens),
+            set: (tokens) => _proxy.$setSessionsForDynamicAuthProvider(this.id, this.clientId, tokens),
         }, initialTokens, this._logger)));
         this._disposable.add(this._tokenStore.onDidChangeSessions(e => this._onDidChangeSessions.fire(e)));
         this._createFlows = [{
-                label: ( localize(2574, "URL Handler")),
+                label: ( localize(2590, "URL Handler")),
                 handler: (scopes, progress, token) => this._createWithUrlHandler(scopes, progress, token)
             }];
     }
+    get clientId() {
+        return this._clientId;
+    }
     async getSessions(scopes, _options) {
         this._logger.info(`Getting sessions for scopes: ${scopes?.join(' ') ?? 'all'}`);
         if (!scopes) {
@@ -260,7 +277,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             try {
                 token = await this._extHostProgress.withProgressFromSource({ label: this.label, id: this.id }, {
                     location: ProgressLocation.Notification,
-                    title: ( localize(2575, "Authenticating to '{0}'", this.label)),
+                    title: ( localize(2591, "Authenticating to '{0}'", this.label)),
                     cancellable: true
                 }, (progress, token) => handler(scopes, progress, token));
                 if (token) {
@@ -274,13 +291,13 @@ let DynamicAuthProvider = class DynamicAuthProvider {
                 }
                 const message = isCancellationError(err)
                     ? ( localize(
-                    2576,
+                    2592,
                     "Having trouble authenticating to '{0}'? Would you like to try a different way? ({1})",
                     this.label,
                     nextMode
                 ))
                     : ( localize(
-                    2577,
+                    2593,
                     "You have not yet finished authenticating to '{0}'. Would you like to try a different way? ({1})",
                     this.label,
                     nextMode
@@ -337,7 +354,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             throw ( new Error(`Failed to create external URI: ${error}`));
         }
         const authorizationUrl = ( new URL(this._serverMetadata.authorization_endpoint));
-        authorizationUrl.searchParams.append('client_id', this.clientId);
+        authorizationUrl.searchParams.append('client_id', this._clientId);
         authorizationUrl.searchParams.append('response_type', 'code');
         authorizationUrl.searchParams.append('state', ( state.toString()));
         authorizationUrl.searchParams.append('code_challenge', codeChallenge);
@@ -359,7 +376,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             throw ( new CancellationError());
         }
         progress.report({
-            message: ( localize(2578, "Complete the authentication in the browser window that has opened.")),
+            message: ( localize(2594, "Complete the authentication in the browser window that has opened.")),
         });
         let code;
         try {
@@ -408,7 +425,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             throw ( new Error('Token endpoint not available in server metadata'));
         }
         const tokenRequest = ( new URLSearchParams());
-        tokenRequest.append('client_id', this.clientId);
+        tokenRequest.append('client_id', this._clientId);
         tokenRequest.append('grant_type', 'authorization_code');
         tokenRequest.append('code', code);
         tokenRequest.append('redirect_uri', redirectUri);
@@ -431,6 +448,11 @@ let DynamicAuthProvider = class DynamicAuthProvider {
         if (isAuthorizationTokenResponse(result)) {
             return result;
         }
+        else if (isAuthorizationErrorResponse(result) && result.error === AuthorizationErrorType.InvalidClient) {
+            this._logger.warn(`Client ID (${this._clientId}) was invalid, generated a new one.`);
+            await this._generateNewClientId();
+            throw ( new Error(`Client ID was invalid, generated a new one. Please try again.`));
+        }
         throw ( new Error(`Invalid authorization token response: ${JSON.stringify(result)}`));
     }
     async exchangeRefreshTokenForToken(refreshToken) {
@@ -438,7 +460,7 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             throw ( new Error('Token endpoint not available in server metadata'));
         }
         const tokenRequest = ( new URLSearchParams());
-        tokenRequest.append('client_id', this.clientId);
+        tokenRequest.append('client_id', this._clientId);
         tokenRequest.append('grant_type', 'refresh_token');
         tokenRequest.append('refresh_token', refreshToken);
         const response = await fetch(this._serverMetadata.token_endpoint, {
@@ -449,12 +471,6 @@ let DynamicAuthProvider = class DynamicAuthProvider {
             },
             body: ( tokenRequest.toString())
         });
-        if (!response.ok) {
-            const text = await response.text();
-            throw ( new Error(
-                `Token exchange failed: ${response.status} ${response.statusText} - ${text}`
-            ));
-        }
         const result = await response.json();
         if (isAuthorizationTokenResponse(result)) {
             return {
@@ -462,8 +478,24 @@ let DynamicAuthProvider = class DynamicAuthProvider {
                 created_at: Date.now(),
             };
         }
+        else if (isAuthorizationErrorResponse(result) && result.error === AuthorizationErrorType.InvalidClient) {
+            this._logger.warn(`Client ID (${this._clientId}) was invalid, generated a new one.`);
+            await this._generateNewClientId();
+            throw ( new Error(`Client ID was invalid, generated a new one. Please try again.`));
+        }
         throw ( new Error(`Invalid authorization token response: ${JSON.stringify(result)}`));
     }
+    async _generateNewClientId() {
+        try {
+            const registration = await fetchDynamicRegistration(this._serverMetadata, this._initData.environment.appName, this._resourceMetadata?.scopes_supported);
+            this._clientId = registration.client_id;
+            this._onDidChangeClientId.fire();
+        }
+        catch (err) {
+            this._logger.error(`Failed to fetch new client ID: ${err}`);
+            throw ( new Error(`Failed to fetch new client ID: ${err}`));
+        }
+    }
 };
 DynamicAuthProvider = ( __decorate([
     ( __param(0, IExtHostWindow)),

package/vscode/src/vs/workbench/api/common/extHostChatAgents2.d.ts

@@ -3,7 +3,7 @@ import { CancellationToken } from "../../../base/common/cancellation.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
-import { IChatAgentRequest, IChatAgentResult } from "../../contrib/chat/common/chatAgents.js";
+import { IChatAgentRequest, IChatAgentResult } from "@codingame/monaco-vscode-9ebd6daf-8734-5a28-ad24-b238f5e5819d-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatRelatedFile, IChatRequestDraft } from "../../contrib/chat/common/chatEditingService.js";
 import { IChatFollowup, IChatUserActionEvent, IChatVoteAction } from "../../contrib/chat/common/chatService.js";
 import { ChatAgentLocation } from "../../contrib/chat/common/constants.js";
@@ -63,4 +63,5 @@ export declare class ExtHostChatAgents2 extends Disposable implements ExtHostCha
     $acceptAction(handle: number, result: IChatAgentResult, event: IChatUserActionEvent): void;
     $invokeCompletionProvider(handle: number, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
     $provideChatTitle(handle: number, context: IChatAgentHistoryEntryDto[], token: CancellationToken): Promise<string | undefined>;
+    $provideChatSummary(handle: number, context: IChatAgentHistoryEntryDto[], token: CancellationToken): Promise<string | undefined>;
 }

package/vscode/src/vs/workbench/api/common/extHostChatAgents2.js

@@ -603,6 +603,14 @@ class ExtHostChatAgents2 extends Disposable {
         const history = await this.prepareHistoryTurns(agent.extension, agent.id, { history: context });
         return await agent.provideTitle({ history }, token);
     }
+    async $provideChatSummary(handle, context, token) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return;
+        }
+        const history = await this.prepareHistoryTurns(agent.extension, agent.id, { history: context });
+        return await agent.provideSummary({ history }, token);
+    }
 }
 class ExtHostParticipantDetector {
     constructor(extension, provider) {
@@ -660,6 +668,12 @@ class ExtHostChatAgent {
         }
         return (await this._titleProvider.provideChatTitle(context, token)) ?? undefined;
     }
+    async provideSummary(context, token) {
+        if (!this._summarizer) {
+            return;
+        }
+        return (await this._summarizer.provideChatSummary(context, token)) ?? undefined;
+    }
     get apiAgent() {
         let disposed = false;
         let updateScheduled = false;
@@ -792,6 +806,14 @@ class ExtHostChatAgent {
                 checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._titleProvider;
             },
+            set summarizer(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                that._summarizer = v;
+            },
+            get summarizer() {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                return that._summarizer;
+            },
             get onDidChangePauseState() {
                 checkProposedApiEnabled(that.extension, 'chatParticipantAdditions');
                 return that._pauseStateEmitter.event;

package/vscode/src/vs/workbench/api/common/extHostCommands.js

@@ -224,6 +224,9 @@ let ExtHostCommands = class ExtHostCommands {
         if (!command.extension) {
             return;
         }
+        if (id.startsWith('code.copilot.logStructured')) {
+            return;
+        }
         this.#telemetry.$publicLog2('Extension:ActionExecuted', {
             extensionId: command.extension.identifier.value,
             id: ( new TelemetryTrustedValue(id)),

package/vscode/src/vs/workbench/api/common/extHostCustomEditors.d.ts

@@ -6,7 +6,7 @@ import { ExtHostDocuments } from "./extHostDocuments.js";
 import { IExtensionStoragePaths } from "./extHostStoragePaths.js";
 import { ExtHostWebviews } from "./extHostWebview.js";
 import { ExtHostWebviewPanels } from "./extHostWebviewPanels.js";
-import { EditorGroupColumn } from "@codingame/monaco-vscode-f48982c4-9e82-55e2-b800-20e6d1e6096f-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
+import { EditorGroupColumn } from "@codingame/monaco-vscode-2726569c-a06b-5f25-b851-14311bef12fa-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
 import type * as vscode from "vscode";
 import * as extHostProtocol from "./extHost.protocol.js";
 export declare class ExtHostCustomEditors implements extHostProtocol.ExtHostCustomEditorsShape {

package/vscode/src/vs/workbench/api/common/extHostDiagnostics.js

@@ -107,7 +107,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            2579,
+                            2595,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),

package/vscode/src/vs/workbench/api/common/extHostDocuments.d.ts

@@ -1,18 +1,20 @@
 import { Event } from "../../../base/common/event.js";
 import { URI, UriComponents } from "../../../base/common/uri.js";
-import { IModelChangedEvent } from "../../../editor/common/model/mirrorTextModel.js";
 import { ExtHostDocumentsShape, IMainContext } from "./extHost.protocol.js";
 import { ExtHostDocumentData } from "./extHostDocumentData.js";
 import { ExtHostDocumentsAndEditors } from "./extHostDocumentsAndEditors.js";
 import type * as vscode from "vscode";
+import { ISerializedModelContentChangedEvent } from "../../../editor/common/textModelEvents.js";
 export declare class ExtHostDocuments implements ExtHostDocumentsShape {
     private readonly _onDidAddDocument;
     private readonly _onDidRemoveDocument;
     private readonly _onDidChangeDocument;
+    private readonly _onDidChangeDocumentWithReason;
     private readonly _onDidSaveDocument;
     readonly onDidAddDocument: Event<vscode.TextDocument>;
     readonly onDidRemoveDocument: Event<vscode.TextDocument>;
     readonly onDidChangeDocument: Event<vscode.TextDocumentChangeEvent>;
+    readonly onDidChangeDocumentWithReason: Event<vscode.TextDocumentChangeEvent>;
     readonly onDidSaveDocument: Event<vscode.TextDocument>;
     private readonly _toDispose;
     private _proxy;
@@ -35,6 +37,6 @@ export declare class ExtHostDocuments implements ExtHostDocumentsShape {
     $acceptModelSaved(uriComponents: UriComponents): void;
     $acceptDirtyStateChanged(uriComponents: UriComponents, isDirty: boolean): void;
     $acceptEncodingChanged(uriComponents: UriComponents, encoding: string): void;
-    $acceptModelChanged(uriComponents: UriComponents, events: IModelChangedEvent, isDirty: boolean): void;
+    $acceptModelChanged(uriComponents: UriComponents, events: ISerializedModelContentChangedEvent, isDirty: boolean): void;
     setWordDefinitionFor(languageId: string, wordDefinition: RegExp | undefined): void;
 }

package/vscode/src/vs/workbench/api/common/extHostDocuments.js

@@ -5,7 +5,7 @@ import { URI } from '../../../base/common/uri.js';
 import { MainContext } from './extHost.protocol.js';
 import { setWordDefinitionFor } from './extHostDocumentData.js';
 import { Range } from './extHostTypeConverters.js';
-import { assertIsDefined } from '../../../base/common/types.js';
+import { assertReturnsDefined } from '../../../base/common/types.js';
 import { deepFreeze } from '../../../base/common/objects.js';
 import { TextDocumentChangeReason } from './extHostTypes.js';
 
@@ -14,10 +14,12 @@ class ExtHostDocuments {
         this._onDidAddDocument = ( new Emitter());
         this._onDidRemoveDocument = ( new Emitter());
         this._onDidChangeDocument = ( new Emitter());
+        this._onDidChangeDocumentWithReason = ( new Emitter());
         this._onDidSaveDocument = ( new Emitter());
         this.onDidAddDocument = this._onDidAddDocument.event;
         this.onDidRemoveDocument = this._onDidRemoveDocument.event;
         this.onDidChangeDocument = this._onDidChangeDocument.event;
+        this.onDidChangeDocumentWithReason = this._onDidChangeDocumentWithReason.event;
         this.onDidSaveDocument = this._onDidSaveDocument.event;
         this._toDispose = ( new DisposableStore());
         this._documentLoader = ( new Map());
@@ -67,7 +69,7 @@ class ExtHostDocuments {
             promise = this._proxy.$tryOpenDocument(uri, options).then(uriData => {
                 this._documentLoader.delete(( uri.toString()));
                 const canonicalUri = URI.revive(uriData);
-                return assertIsDefined(this._documentsAndEditors.getDocument(canonicalUri));
+                return assertReturnsDefined(this._documentsAndEditors.getDocument(canonicalUri));
             }, err => {
                 this._documentLoader.delete(( uri.toString()));
                 return Promise.reject(err);
@@ -118,7 +120,13 @@ class ExtHostDocuments {
         this._onDidChangeDocument.fire({
             document: data.document,
             contentChanges: [],
-            reason: undefined
+            reason: undefined,
+        });
+        this._onDidChangeDocumentWithReason.fire({
+            document: data.document,
+            contentChanges: [],
+            reason: undefined,
+            detailedReason: undefined,
         });
     }
     $acceptEncodingChanged(uriComponents, encoding) {
@@ -131,7 +139,13 @@ class ExtHostDocuments {
         this._onDidChangeDocument.fire({
             document: data.document,
             contentChanges: [],
-            reason: undefined
+            reason: undefined,
+        });
+        this._onDidChangeDocumentWithReason.fire({
+            document: data.document,
+            contentChanges: [],
+            reason: undefined,
+            detailedReason: undefined,
         });
     }
     $acceptModelChanged(uriComponents, events, isDirty) {
@@ -159,7 +173,23 @@ class ExtHostDocuments {
                     text: change.text
                 };
             })),
-            reason
+            reason,
+        }));
+        this._onDidChangeDocumentWithReason.fire(deepFreeze({
+            document: data.document,
+            contentChanges: ( events.changes.map((change) => {
+                return {
+                    range: Range.to(change.range),
+                    rangeOffset: change.rangeOffset,
+                    rangeLength: change.rangeLength,
+                    text: change.text
+                };
+            })),
+            reason,
+            detailedReason: events.detailedReason ? {
+                source: events.detailedReason.source,
+                metadata: events.detailedReason,
+            } : undefined,
         }));
     }
     setWordDefinitionFor(languageId, wordDefinition) {

package/vscode/src/vs/workbench/api/common/extHostEditorTabs.js

@@ -2,7 +2,7 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { diffSets } from '../../../base/common/collections.js';
 import { Emitter } from '../../../base/common/event.js';
-import { assertIsDefined } from '../../../base/common/types.js';
+import { assertReturnsDefined } from '../../../base/common/types.js';
 import { URI } from '../../../base/common/uri.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { TabInputKind, TabModelOperationKind, MainContext } from './extHost.protocol.js';
@@ -204,7 +204,7 @@ let ExtHostEditorTabs = class ExtHostEditorTabs {
                 },
                 get activeTabGroup() {
                     const activeTabGroupId = that._activeGroupId;
-                    const activeTabGroup = assertIsDefined(that._extHostTabGroups.find(candidate => candidate.groupId === activeTabGroupId)?.apiObject);
+                    const activeTabGroup = assertReturnsDefined(that._extHostTabGroups.find(candidate => candidate.groupId === activeTabGroupId)?.apiObject);
                     return activeTabGroup;
                 },
                 close: async (tabOrTabGroup, preserveFocus) => {
@@ -241,7 +241,7 @@ let ExtHostEditorTabs = class ExtHostEditorTabs {
             }
             return group;
         }));
-        const activeTabGroupId = assertIsDefined(tabGroups.find(group => group.isActive === true)?.groupId);
+        const activeTabGroupId = assertReturnsDefined(tabGroups.find(group => group.isActive === true)?.groupId);
         if (activeTabGroupId !== undefined && this._activeGroupId !== activeTabGroupId) {
             this._activeGroupId = activeTabGroupId;
         }

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -415,8 +415,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             try {
                 activationTimesBuilder.activateCallStart();
                 logService.trace(`ExtensionService#_callActivateOptional ${extensionId.value}`);
-                const scope = typeof global === 'object' ? global : self;
-                const activateResult = extensionModule.activate.apply(scope, [context]);
+                const activateResult = extensionModule.activate.apply(globalThis, [context]);
                 activationTimesBuilder.activateCallStop();
                 activationTimesBuilder.activateResolveStart();
                 return Promise.resolve(activateResult).then((value) => {
@@ -541,7 +540,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     async _doHandleExtensionTests() {
         const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2580, "Cannot load test runner."))));
+            throw ( new Error(( localize(2596, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
@@ -550,7 +549,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
         if (!testRunner || typeof testRunner.run !== 'function') {
             throw ( new Error(( localize(
-                2581,
+                2597,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));

package/vscode/src/vs/workbench/api/common/extHostLanguageFeatures.d.ts

@@ -104,7 +104,6 @@ export declare class ExtHostLanguageFeatures implements extHostProtocol.ExtHostL
     $releaseCompletionItems(handle: number, id: number): void;
     registerInlineCompletionsProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.InlineCompletionItemProvider, metadata: vscode.InlineCompletionItemProviderMetadata | undefined): vscode.Disposable;
     $provideInlineCompletions(handle: number, resource: UriComponents, position: IPosition, context: languages.InlineCompletionContext, token: CancellationToken): Promise<extHostProtocol.IdentifiableInlineCompletions | undefined>;
-    $provideInlineEditsForRange(handle: number, resource: UriComponents, range: IRange, context: languages.InlineCompletionContext, token: CancellationToken): Promise<extHostProtocol.IdentifiableInlineCompletions | undefined>;
     $handleInlineCompletionDidShow(handle: number, pid: number, idx: number, updatedInsertText: string): void;
     $handleInlineCompletionPartialAccept(handle: number, pid: number, idx: number, acceptedCharacters: number, info: languages.PartialAcceptInfo): void;
     $handleInlineCompletionEndOfLifetime(handle: number, pid: number, idx: number, reason: languages.InlineCompletionEndOfLifeReason<{
@@ -112,10 +111,7 @@ export declare class ExtHostLanguageFeatures implements extHostProtocol.ExtHostL
         idx: number;
     }>): void;
     $handleInlineCompletionRejection(handle: number, pid: number, idx: number): void;
-    $freeInlineCompletionsList(handle: number, pid: number): void;
-    registerInlineEditProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.InlineEditProvider): vscode.Disposable;
-    $provideInlineEdit(handle: number, resource: UriComponents, context: languages.IInlineEditContext, token: CancellationToken): Promise<extHostProtocol.IdentifiableInlineEdit | undefined>;
-    $freeInlineEdit(handle: number, pid: number): void;
+    $freeInlineCompletionsList(handle: number, pid: number, reason: languages.InlineCompletionsDisposeReason): void;
     registerSignatureHelpProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, metadataOrTriggerChars: string[] | vscode.SignatureHelpProviderMetadata): vscode.Disposable;
     $provideSignatureHelp(handle: number, resource: UriComponents, position: IPosition, context: extHostProtocol.ISignatureHelpContextDto, token: CancellationToken): Promise<extHostProtocol.ISignatureHelpDto | undefined>;
     $releaseSignatureHelp(handle: number, id: number): void;