@codingame/monaco-vscode-chat-service-override 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceImpl.js

@@ -33,6 +33,7 @@ import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/c
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
+const _moduleId = "vs/workbench/contrib/chat/common/chatServiceImpl";
 const serializedChatKey = 'interactive.sessions';
 const globalChatKey = 'chat.workspaceTransfer';
 const SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS = 1000 * 60;
@@ -55,23 +56,23 @@ let ChatService = class ChatService extends Disposable {
         this.chatAgentService = chatAgentService;
         this.notificationService = notificationService;
         this.commandService = commandService;
-        this._providers = ( new Map());
-        this._sessionModels = this._register(( new DisposableMap()));
-        this._pendingRequests = this._register(( new DisposableMap()));
-        this._onDidPerformUserAction = this._register(( new Emitter()));
+        this._providers = ( (new Map()));
+        this._sessionModels = this._register(( (new DisposableMap())));
+        this._pendingRequests = this._register(( (new DisposableMap())));
+        this._onDidPerformUserAction = this._register(( (new Emitter())));
         this.onDidPerformUserAction = this._onDidPerformUserAction.event;
-        this._onDidDisposeSession = this._register(( new Emitter()));
+        this._onDidDisposeSession = this._register(( (new Emitter())));
         this.onDidDisposeSession = this._onDidDisposeSession.event;
-        this._onDidRegisterProvider = this._register(( new Emitter()));
+        this._onDidRegisterProvider = this._register(( (new Emitter())));
         this.onDidRegisterProvider = this._onDidRegisterProvider.event;
-        this._onDidUnregisterProvider = this._register(( new Emitter()));
+        this._onDidUnregisterProvider = this._register(( (new Emitter())));
         this.onDidUnregisterProvider = this._onDidUnregisterProvider.event;
-        this._sessionFollowupCancelTokens = this._register(( new DisposableMap()));
+        this._sessionFollowupCancelTokens = this._register(( (new DisposableMap())));
         this._hasProvider = CONTEXT_PROVIDER_EXISTS.bindTo(this.contextKeyService);
         const sessionData = storageService.get(serializedChatKey, 1 , '');
         if (sessionData) {
             this._persistedSessions = this.deserializeChats(sessionData);
-            const countsForLog = ( Object.keys(this._persistedSessions)).length;
+            const countsForLog = ( (Object.keys(this._persistedSessions))).length;
             if (countsForLog > 0) {
                 this.trace('constructor', `Restored ${countsForLog} persisted sessions`);
             }
@@ -89,11 +90,11 @@ let ChatService = class ChatService extends Disposable {
         this._register(storageService.onWillSaveState(() => this.saveState()));
     }
     saveState() {
-        let allSessions = Array.from(( this._sessionModels.values()))
+        let allSessions = Array.from(( (this._sessionModels.values())))
             .filter(session => !session.providerId.startsWith('inlinechat:'))
             .filter(session => session.getRequests().length > 0);
-        allSessions = allSessions.concat(( Object.values(this._persistedSessions))
-            .filter(session => !( this._sessionModels.has(session.sessionId)))
+        allSessions = allSessions.concat(( (Object.values(this._persistedSessions)))
+            .filter(session => !( (this._sessionModels.has(session.sessionId))))
             .filter(session => session.requests.length));
         allSessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
         allSessions = allSessions.slice(0, maxPersistedSessions);
@@ -151,20 +152,22 @@ let ChatService = class ChatService extends Disposable {
         try {
             const arrayOfSessions = revive(JSON.parse(sessionData));
             if (!Array.isArray(arrayOfSessions)) {
-                throw new Error('Expected array');
+                throw ( (new Error('Expected array')));
             }
             const sessions = arrayOfSessions.reduce((acc, session) => {
                 for (const request of session.requests) {
                     if (Array.isArray(request.response)) {
-                        request.response = ( request.response.map((response) => {
+                        request.response = ( (request.response.map((response) => {
                             if (typeof response === 'string') {
-                                return ( new MarkdownString(response));
+                                return (
+                                     (new MarkdownString(response))
+                                );
                             }
                             return response;
-                        }));
+                        })));
                     }
                     else if (typeof request.response === 'string') {
-                        request.response = [( new MarkdownString(request.response))];
+                        request.response = [( (new MarkdownString(request.response)))];
                     }
                 }
                 acc[session.sessionId] = session;
@@ -183,27 +186,29 @@ let ChatService = class ChatService extends Disposable {
         if (!workspaceUri) {
             return;
         }
-        const thisWorkspace = ( workspaceUri.toString());
+        const thisWorkspace = ( (workspaceUri.toString()));
         const currentTime = Date.now();
-        const transferred = data.find(item => ( URI.revive(item.toWorkspace).toString()) === thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
-        const filtered = data.filter(item => ( URI.revive(item.toWorkspace).toString()) !== thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
+        const transferred = data.find(item => ( (URI.revive(item.toWorkspace).toString())) === thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
+        const filtered = data.filter(item => ( (URI.revive(item.toWorkspace).toString())) !== thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
         this.storageService.store(globalChatKey, JSON.stringify(filtered), 0 , 1 );
         return transferred;
     }
     getHistory() {
-        const sessions = ( Object.values(this._persistedSessions))
+        const sessions = ( (Object.values(this._persistedSessions)))
             .filter(session => session.requests.length > 0);
         sessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
-        return ( sessions
-            .filter(session => !( this._sessionModels.has(session.sessionId)))
-            .filter(session => !session.isImported)
-            .map(item => {
-            const title = ChatModel.getDefaultTitle(item.requests);
-            return {
-                sessionId: item.sessionId,
-                title
-            };
-        }));
+        return (
+             (sessions
+                .filter(session => !( (this._sessionModels.has(session.sessionId))))
+                .filter(session => !session.isImported)
+                .map(item => {
+                const title = ChatModel.getDefaultTitle(item.requests);
+                return {
+                    sessionId: item.sessionId,
+                    title
+                };
+            }))
+        );
     }
     removeHistoryEntry(sessionId) {
         delete this._persistedSessions[sessionId];
@@ -235,7 +240,7 @@ let ChatService = class ChatService extends Disposable {
             await this.extensionService.activateByEvent(`onInteractiveSession:${model.providerId}`);
             const provider = this._providers.get(model.providerId);
             if (!provider) {
-                throw new ErrorNoTelemetry(`Unknown provider: ${model.providerId}`);
+                throw ( (new ErrorNoTelemetry(`Unknown provider: ${model.providerId}`)));
             }
             let session;
             try {
@@ -245,7 +250,7 @@ let ChatService = class ChatService extends Disposable {
                 this.trace('initializeSession', `Provider initializeSession threw: ${err}`);
             }
             if (!session) {
-                throw new Error('Provider returned no session');
+                throw ( (new Error('Provider returned no session')));
             }
             this.trace('startSession', `Provider returned session`);
             const defaultAgent = this.chatAgentService.getDefaultAgent(ChatAgentLocation.Panel);
@@ -253,26 +258,24 @@ let ChatService = class ChatService extends Disposable {
                 this.notificationService.notify({
                     severity: Severity$1.Error,
                     message: ( localizeWithPath(
-                        'vs/workbench/contrib/chat/common/chatServiceImpl',
-                        'chatFailErrorMessage',
+                        _moduleId,
+                        0,
                         "Chat failed to load. Please ensure that the GitHub Copilot Chat extension is up to date."
                     )),
                     actions: {
                         primary: [
-                            ( new Action('showExtension', ( localizeWithPath(
-                                'vs/workbench/contrib/chat/common/chatServiceImpl',
-                                'action.showExtension',
-                                "Show Extension"
-                            )), undefined, true, () => {
-                                return this.commandService.executeCommand('workbench.extensions.action.showExtensionsWithIds', ['GitHub.copilot-chat']);
-                            }))
+                            ( (new Action('showExtension', ( localizeWithPath(_moduleId, 1, "Show Extension")), undefined, true, () => {
+                            return this.commandService.executeCommand('workbench.extensions.action.showExtensionsWithIds', ['GitHub.copilot-chat']);
+                        })))
                         ]
                     }
                 });
-                throw new ErrorNoTelemetry('No default agent');
+                throw ( (new ErrorNoTelemetry('No default agent')));
             }
             const welcomeMessage = model.welcomeMessage ? undefined : (await defaultAgent.provideWelcomeMessage?.(token)) ?? undefined;
-            const welcomeModel = welcomeMessage && this.instantiationService.createInstance(ChatWelcomeMessageModel, ( welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item)), (await defaultAgent.provideSampleQuestions?.(token)) ?? []);
+            const welcomeModel = welcomeMessage && this.instantiationService.createInstance(ChatWelcomeMessageModel, ( (welcomeMessage.map(
+                item => typeof item === 'string' ? ( (new MarkdownString(item))) : item
+            ))), (await defaultAgent.provideSampleQuestions?.(token)) ?? []);
             model.initialize(session, welcomeModel);
         }
         catch (err) {
@@ -286,7 +289,7 @@ let ChatService = class ChatService extends Disposable {
         return this._sessionModels.get(sessionId);
     }
     getSessionId(sessionProviderId) {
-        return Iterable.find(( this._sessionModels.values()), model => model.session?.id === sessionProviderId)?.sessionId;
+        return Iterable.find(( (this._sessionModels.values())), model => model.session?.id === sessionProviderId)?.sessionId;
     }
     getOrRestoreSession(sessionId) {
         this.trace('getOrRestoreSession', `sessionId: ${sessionId}`);
@@ -314,14 +317,14 @@ let ChatService = class ChatService extends Disposable {
         }
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         await model.waitForInitialization();
         const provider = this._providers.get(model.providerId);
         if (!provider) {
-            throw new Error(`Unknown provider: ${model.providerId}`);
+            throw ( (new Error(`Unknown provider: ${model.providerId}`)));
         }
-        if (( this._pendingRequests.has(sessionId))) {
+        if (( (this._pendingRequests.has(sessionId)))) {
             this.trace('sendRequest', `Session ${sessionId} already has a pending request`);
             return;
         }
@@ -337,7 +340,7 @@ let ChatService = class ChatService extends Disposable {
     }
     refreshFollowupsCancellationToken(sessionId) {
         this._sessionFollowupCancelTokens.get(sessionId)?.cancel();
-        const newTokenSource = ( new CancellationTokenSource());
+        const newTokenSource = ( (new CancellationTokenSource()));
         this._sessionFollowupCancelTokens.set(sessionId, newTokenSource);
         return newTokenSource.token;
     }
@@ -349,7 +352,7 @@ let ChatService = class ChatService extends Disposable {
         const commandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestSlashCommandPart);
         let gotProgress = false;
         const requestType = commandPart ? 'slashCommand' : 'string';
-        const source = ( new CancellationTokenSource());
+        const source = ( (new CancellationTokenSource()));
         const token = source.token;
         const sendRequestInternal = async () => {
             const progressCallback = (progress) => {
@@ -365,7 +368,7 @@ let ChatService = class ChatService extends Disposable {
                 }
                 model.acceptResponseProgress(request, progress);
             };
-            const stopWatch = ( new StopWatch(false));
+            const stopWatch = ( (new StopWatch(false)));
             const listener = token.onCancellationRequested(() => {
                 this.trace('sendRequest', `Request for session ${model.sessionId} was cancelled`);
                 this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
@@ -396,9 +399,9 @@ let ChatService = class ChatService extends Disposable {
                     if (implicitVariablesEnabled) {
                         const implicitVariables = agent.defaultImplicitVariables;
                         if (implicitVariables) {
-                            const resolvedImplicitVariables = await Promise.all(( implicitVariables.map(
+                            const resolvedImplicitVariables = await Promise.all(( (implicitVariables.map(
                                 async (v) => ({ name: v, values: await this.chatVariablesService.resolveVariable(v, parsedRequest.text, model, progressCallback, token) })
-                            )));
+                            ))));
                             updatedVariableData.variables.push(...resolvedImplicitVariables);
                         }
                     }
@@ -426,14 +429,14 @@ let ChatService = class ChatService extends Disposable {
                         history.push({ role: 2 , content: request.response.response.asString() });
                     }
                     const message = parsedRequest.text;
-                    const commandResult = await this.chatSlashCommandService.executeCommand(commandPart.slashCommand.command, message.substring(commandPart.slashCommand.command.length + 1).trimStart(), ( new Progress(p => {
+                    const commandResult = await this.chatSlashCommandService.executeCommand(commandPart.slashCommand.command, message.substring(commandPart.slashCommand.command.length + 1).trimStart(), ( (new Progress(p => {
                         progressCallback(p);
-                    })), history, token);
+                    }))), history, token);
                     agentOrCommandFollowups = Promise.resolve(commandResult?.followUp);
                     rawResult = {};
                 }
                 else {
-                    throw new Error(`Cannot handle request`);
+                    throw ( (new Error(`Cannot handle request`)));
                 }
                 if (token.isCancellationRequested) {
                     return;
@@ -441,11 +444,7 @@ let ChatService = class ChatService extends Disposable {
                 else {
                     if (!rawResult) {
                         this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localizeWithPath(
-                            'vs/workbench/contrib/chat/common/chatServiceImpl',
-                            'emptyResponse',
-                            "Provider returned null response"
-                        )) } };
+                        rawResult = { errorDetails: { message: ( localizeWithPath(_moduleId, 2, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
@@ -485,23 +484,23 @@ let ChatService = class ChatService extends Disposable {
     async removeRequest(sessionId, requestId) {
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         await model.waitForInitialization();
         const provider = this._providers.get(model.providerId);
         if (!provider) {
-            throw new Error(`Unknown provider: ${model.providerId}`);
+            throw ( (new Error(`Unknown provider: ${model.providerId}`)));
         }
         model.removeRequest(requestId);
     }
     getProviders() {
-        return Array.from(( this._providers.keys()));
+        return Array.from(( (this._providers.keys())));
     }
     async addCompleteRequest(sessionId, message, variableData, response) {
         this.trace('addCompleteRequest', `message: ${message}`);
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         await model.waitForInitialization();
         const parsedRequest = typeof message === 'string' ?
@@ -531,7 +530,7 @@ let ChatService = class ChatService extends Disposable {
         this.trace('clearSession', `sessionId: ${sessionId}`);
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         if (!model.providerId.startsWith('inlinechat')) {
             this._persistedSessions[sessionId] = model.toJSON();
@@ -543,13 +542,13 @@ let ChatService = class ChatService extends Disposable {
     }
     registerProvider(provider) {
         this.trace('registerProvider', `Adding new chat provider`);
-        if (( this._providers.has(provider.id))) {
-            throw new Error(`Provider ${provider.id} already registered`);
+        if (( (this._providers.has(provider.id)))) {
+            throw ( (new Error(`Provider ${provider.id} already registered`)));
         }
         this._providers.set(provider.id, provider);
         this._hasProvider.set(true);
         this._onDidRegisterProvider.fire({ providerId: provider.id });
-        Array.from(( this._sessionModels.values()))
+        Array.from(( (this._sessionModels.values())))
             .filter(model => model.providerId === provider.id)
             .filter(model => model.initState === ChatModelInitState.Created)
             .forEach(model => this.reinitializeModel(model));
@@ -557,26 +556,30 @@ let ChatService = class ChatService extends Disposable {
             this.trace('registerProvider', `Disposing chat provider`);
             this._providers.delete(provider.id);
             this._hasProvider.set(this._providers.size > 0);
-            Array.from(( this._sessionModels.values()))
+            Array.from(( (this._sessionModels.values())))
                 .filter(model => model.providerId === provider.id)
                 .forEach(model => model.deinitialize());
             this._onDidUnregisterProvider.fire({ providerId: provider.id });
         });
     }
     hasSessions(providerId) {
-        return !!( Object.values(this._persistedSessions)).find((session) => session.providerId === providerId);
+        return !!( (Object.values(this._persistedSessions))).find((session) => session.providerId === providerId);
     }
     getProviderInfos() {
-        return ( Array.from(( this._providers.values())).map(provider => {
-            return {
-                id: provider.id,
-            };
-        }));
+        return (
+             (Array.from(( (this._providers.values()))).map(provider => {
+                return {
+                    id: provider.id,
+                };
+            }))
+        );
     }
     transferChatSession(transferredSessionData, toWorkspace) {
-        const model = Iterable.find(( this._sessionModels.values()), model => model.sessionId === transferredSessionData.sessionId);
+        const model = Iterable.find(( (this._sessionModels.values())), model => model.sessionId === transferredSessionData.sessionId);
         if (!model) {
-            throw new Error(`Failed to transfer session. Unknown session ID: ${transferredSessionData.sessionId}`);
+            throw ( (new Error(
+                `Failed to transfer session. Unknown session ID: ${transferredSessionData.sessionId}`
+            )));
         }
         const existingRaw = this.storageService.getObject(globalChatKey, 0 , []);
         existingRaw.push({
@@ -586,22 +589,22 @@ let ChatService = class ChatService extends Disposable {
             inputValue: transferredSessionData.inputValue,
         });
         this.storageService.store(globalChatKey, JSON.stringify(existingRaw), 0 , 1 );
-        this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( toWorkspace.toString())}`);
+        this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( (toWorkspace.toString()))}`);
     }
 };
-ChatService = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IExtensionService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IWorkspaceContextService)),
-    ( __param(7, IChatSlashCommandService)),
-    ( __param(8, IChatVariablesService)),
-    ( __param(9, IChatAgentService)),
-    ( __param(10, INotificationService)),
-    ( __param(11, ICommandService))
-], ChatService));
+ChatService = ( (__decorate([
+    ( (__param(0, IStorageService))),
+    ( (__param(1, ILogService))),
+    ( (__param(2, IExtensionService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, ITelemetryService))),
+    ( (__param(5, IContextKeyService))),
+    ( (__param(6, IWorkspaceContextService))),
+    ( (__param(7, IChatSlashCommandService))),
+    ( (__param(8, IChatVariablesService))),
+    ( (__param(9, IChatAgentService))),
+    ( (__param(10, INotificationService))),
+    ( (__param(11, ICommandService)))
+], ChatService)));
 
 export { ChatService };

package/vscode/src/vs/workbench/contrib/chat/common/chatSlashCommands.js

@@ -17,7 +17,7 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
     }
     registerSlashCommand(data, command) {
         if (( this._commands.has(data.command))) {
-            throw new Error(`Already registered a command with id ${data.command}}`);
+            throw ( new Error(`Already registered a command with id ${data.command}}`));
         }
         this._commands.set(data.command, { data, command });
         this._onDidChangeCommands.fire();
@@ -36,13 +36,13 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
     async executeCommand(id, prompt, progress, history, token) {
         const data = this._commands.get(id);
         if (!data) {
-            throw new Error('No command with id ${id} NOT registered');
+            throw ( new Error('No command with id ${id} NOT registered'));
         }
         if (!data.command) {
             await this._extensionService.activateByEvent(`onSlash:${id}`);
         }
         if (!data.command) {
-            throw new Error(`No command with id ${id} NOT resolved`);
+            throw ( new Error(`No command with id ${id} NOT resolved`));
         }
         return await data.command(prompt, progress, history, token);
     }

package/vscode/src/vs/workbench/contrib/chat/common/languageModels.js

@@ -19,7 +19,9 @@ class LanguageModelsService {
     }
     registerLanguageModelChat(identifier, provider) {
         if (( this._providers.has(identifier))) {
-            throw new Error(`Chat response provider with identifier ${identifier} is already registered.`);
+            throw ( new Error(
+                `Chat response provider with identifier ${identifier} is already registered.`
+            ));
         }
         this._providers.set(identifier, provider);
         this._onDidChangeProviders.fire({ added: [provider.metadata] });
@@ -32,7 +34,7 @@ class LanguageModelsService {
     makeLanguageModelChatRequest(identifier, from, messages, options, progress, token) {
         const provider = this._providers.get(identifier);
         if (!provider) {
-            throw new Error(`Chat response provider with identifier ${identifier} is not registered.`);
+            throw ( new Error(`Chat response provider with identifier ${identifier} is not registered.`));
         }
         return provider.provideChatResponse(messages, from, options, progress, token);
     }

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl.js

@@ -19,6 +19,7 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 
+const _moduleId = "vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl";
 let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
     constructor(_fileConfigService, _editorGroupService, _textFileService, _editorService, _inlineChatSessionService, _configService, _workingCopyFileService, _logService) {
         this._fileConfigService = _fileConfigService;
@@ -29,19 +30,19 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         this._configService = _configService;
         this._workingCopyFileService = _workingCopyFileService;
         this._logService = _logService;
-        this._store = ( new DisposableStore());
-        this._saveParticipant = this._store.add(( new MutableDisposable()));
-        this._sessionData = ( new Map());
+        this._store = ( (new DisposableStore()));
+        this._saveParticipant = this._store.add(( (new MutableDisposable())));
+        this._sessionData = ( (new Map()));
         this._store.add(Event.any(_inlineChatSessionService.onDidEndSession, _inlineChatSessionService.onDidStashSession)(e => {
             this._sessionData.get(e.session)?.dispose();
         }));
     }
     dispose() {
         this._store.dispose();
-        dispose(( this._sessionData.values()));
+        dispose(( (this._sessionData.values())));
     }
     markChanged(session) {
-        if (!( this._sessionData.has(session))) {
+        if (!( (this._sessionData.has(session)))) {
             let uri = session.targetUri;
             if (uri.scheme === Schemas.vscodeNotebookCell) {
                 const data = CellUri.parse(uri);
@@ -69,7 +70,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         }
     }
     _installSaveParticpant() {
-        const queue = ( new Queue());
+        const queue = ( (new Queue()));
         const d1 = this._textFileService.files.addSaveParticipant({
             participate: (model, ctx, progress, token) => {
                 return queue.queue(() => this._participate(ctx.savedFrom ?? model.textEditorModel?.uri, ctx.reason, progress, token));
@@ -89,9 +90,9 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         if (!this._configService.getValue("inlineChat.acceptedOrDiscardBeforeSave" )) {
             return;
         }
-        const sessions = ( new Map());
+        const sessions = ( (new Map()));
         for (const [session, data] of this._sessionData) {
-            if (uri?.toString() === ( data.resourceUri.toString())) {
+            if (uri?.toString() === ( (data.resourceUri.toString()))) {
                 sessions.set(session, data);
             }
         }
@@ -101,29 +102,29 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         progress.report({
             message: sessions.size === 1
                 ? ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
-                'inlineChat',
+                _moduleId,
+                0,
                 "Waiting for Inline Chat changes to be Accepted or Discarded..."
             ))
                 : ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
-                'inlineChat.N',
+                _moduleId,
+                1,
                 "Waiting for Inline Chat changes in {0} editors to be Accepted or Discarded...",
                 sessions.size
             ))
         });
-        const { groups, orphans } = this._getGroupsAndOrphans(( sessions.values()));
+        const { groups, orphans } = this._getGroupsAndOrphans(( (sessions.values())));
         const editorsOpenedAndSessionsEnded = this._openAndWait(groups, token).then(() => {
             if (token.isCancellationRequested) {
                 return;
             }
-            return this._openAndWait(( Iterable.map(orphans, s => [this._editorGroupService.activeGroup, s])), token);
+            return this._openAndWait(( (Iterable.map(orphans, s => [this._editorGroupService.activeGroup, s]))), token);
         });
-        const allSessionsEnded = this._whenSessionsEnded(Iterable.concat(( groups.map(tuple => tuple[1])), orphans), token);
+        const allSessionsEnded = this._whenSessionsEnded(Iterable.concat(( (groups.map(tuple => tuple[1]))), orphans), token);
         await Promise.race([allSessionsEnded, editorsOpenedAndSessionsEnded]);
     }
     _getGroupsAndOrphans(sessions) {
-        const groupByEditor = ( new Map());
+        const groupByEditor = ( (new Map()));
         for (const group of this._editorGroupService.getGroups(1 )) {
             const candidate = group.activeEditorPane?.getControl();
             if (isCodeEditor(candidate)) {
@@ -131,7 +132,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
             }
         }
         const groups = [];
-        const orphans = ( new Set());
+        const orphans = ( (new Set()));
         for (const data of sessions) {
             const editor = this._inlineChatSessionService.getCodeEditor(data.session);
             const group = groupByEditor.get(editor);
@@ -148,7 +149,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         return { groups, orphans };
     }
     async _openAndWait(groups, token) {
-        const dataByGroup = ( new Map());
+        const dataByGroup = ( (new Map()));
         for (const [group, data] of groups) {
             let array = dataByGroup.get(group);
             if (!array) {
@@ -161,7 +162,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
             if (token.isCancellationRequested) {
                 break;
             }
-            array.sort((a, b) => compare(( a.session.targetUri.toString()), ( b.session.targetUri.toString())));
+            array.sort((a, b) => compare(( (a.session.targetUri.toString())), ( (b.session.targetUri.toString()))));
             for (const data of array) {
                 const input = { resource: data.resourceUri };
                 const pane = await this._editorService.openEditor(input, group);
@@ -174,7 +175,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
                         if (cell) {
                             await notebookEditor.revealRangeInCenterIfOutsideViewportAsync(cell, data.session.wholeRange.value);
                         }
-                        const tuple = notebookEditor.codeEditors.find(tuple => tuple[1].getModel()?.uri.toString() === ( data.session.targetUri.toString()));
+                        const tuple = notebookEditor.codeEditors.find(tuple => tuple[1].getModel()?.uri.toString() === ( (data.session.targetUri.toString())));
                         editor = tuple?.[1];
                     }
                 }
@@ -188,13 +189,13 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
                 }
                 this._inlineChatSessionService.moveSession(data.session, editor);
                 InlineChatController.get(editor)?.showSaveHint();
-                this._logService.info('WAIT for session to end', editor.getId(), ( data.session.targetUri.toString()));
+                this._logService.info('WAIT for session to end', editor.getId(), ( (data.session.targetUri.toString())));
                 await this._whenSessionsEnded(Iterable.single(data), token);
             }
         }
     }
     async _whenSessionsEnded(iterable, token) {
-        const sessions = ( new Map());
+        const sessions = ( (new Map()));
         for (const item of iterable) {
             sessions.set(item.session, item);
         }
@@ -202,7 +203,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
             return;
         }
         let listener;
-        const whenEnded = ( new Promise(resolve => {
+        const whenEnded = ( (new Promise(resolve => {
             listener = Event.any(this._inlineChatSessionService.onDidEndSession, this._inlineChatSessionService.onDidStashSession)(e => {
                 const data = sessions.get(e.session);
                 if (data) {
@@ -213,7 +214,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
                     }
                 }
             });
-        }));
+        })));
         try {
             await raceCancellation(whenEnded, token);
         }
@@ -222,15 +223,15 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         }
     }
 };
-InlineChatSavingServiceImpl = ( __decorate([
-    ( __param(0, IFilesConfigurationService)),
-    ( __param(1, IEditorGroupsService)),
-    ( __param(2, ITextFileService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IInlineChatSessionService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IWorkingCopyFileService)),
-    ( __param(7, ILogService))
-], InlineChatSavingServiceImpl));
+InlineChatSavingServiceImpl = ( (__decorate([
+    ( (__param(0, IFilesConfigurationService))),
+    ( (__param(1, IEditorGroupsService))),
+    ( (__param(2, ITextFileService))),
+    ( (__param(3, IEditorService))),
+    ( (__param(4, IInlineChatSessionService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IWorkingCopyFileService))),
+    ( (__param(7, ILogService)))
+], InlineChatSavingServiceImpl)));
 
 export { InlineChatSavingServiceImpl };