@codingame/monaco-vscode-chat-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,141 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { rtrim } from 'vscode/vscode/vs/base/common/strings';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { chatAgentLeader, chatSubcommandLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { SpeechToTextStatus, ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
+
+var VoiceChatService_1;
+var PhraseTextType;
+( (function(PhraseTextType) {
+    PhraseTextType[PhraseTextType["AGENT"] = 1] = "AGENT";
+    PhraseTextType[PhraseTextType["COMMAND"] = 2] = "COMMAND";
+    PhraseTextType[PhraseTextType["AGENT_AND_COMMAND"] = 3] = "AGENT_AND_COMMAND";
+})(PhraseTextType || (PhraseTextType = {})));
+let VoiceChatService = class VoiceChatService extends Disposable {
+    static { VoiceChatService_1 = this; }
+    static { this.AGENT_PREFIX = chatAgentLeader; }
+    static { this.COMMAND_PREFIX = chatSubcommandLeader; }
+    static { this.PHRASES_LOWER = {
+        [VoiceChatService_1.AGENT_PREFIX]: 'at',
+        [VoiceChatService_1.COMMAND_PREFIX]: 'slash'
+    }; }
+    static { this.PHRASES_UPPER = {
+        [VoiceChatService_1.AGENT_PREFIX]: 'At',
+        [VoiceChatService_1.COMMAND_PREFIX]: 'Slash'
+    }; }
+    static { this.CHAT_AGENT_ALIAS = ( new Map([['vscode', 'code']])); }
+    constructor(speechService, chatAgentService) {
+        super();
+        this.speechService = speechService;
+        this.chatAgentService = chatAgentService;
+    }
+    createPhrases(model) {
+        const phrases = ( new Map());
+        for (const agent of this.chatAgentService.getActivatedAgents()) {
+            const agentPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]} ${VoiceChatService_1.CHAT_AGENT_ALIAS.get(agent.id) ?? agent.id}`.toLowerCase();
+            phrases.set(agentPhrase, { agent: agent.id });
+            for (const slashCommand of agent.slashCommands) {
+                const slashCommandPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.COMMAND_PREFIX]} ${slashCommand.name}`.toLowerCase();
+                phrases.set(slashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+                const agentSlashCommandPhrase = `${agentPhrase} ${slashCommandPhrase}`.toLowerCase();
+                phrases.set(agentSlashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+            }
+        }
+        return phrases;
+    }
+    toText(value, type) {
+        switch (type) {
+            case PhraseTextType.AGENT:
+                return `${VoiceChatService_1.AGENT_PREFIX}${value.agent}`;
+            case PhraseTextType.COMMAND:
+                return `${VoiceChatService_1.COMMAND_PREFIX}${value.command}`;
+            case PhraseTextType.AGENT_AND_COMMAND:
+                return `${VoiceChatService_1.AGENT_PREFIX}${value.agent} ${VoiceChatService_1.COMMAND_PREFIX}${value.command}`;
+        }
+    }
+    async createVoiceChatSession(token, options) {
+        const disposables = ( new DisposableStore());
+        disposables.add(token.onCancellationRequested(() => disposables.dispose()));
+        let detectedAgent = false;
+        let detectedSlashCommand = false;
+        const emitter = disposables.add(( new Emitter()));
+        const session = await this.speechService.createSpeechToTextSession(token, 'chat');
+        const phrases = this.createPhrases(options.model);
+        disposables.add(session.onDidChange(e => {
+            switch (e.status) {
+                case SpeechToTextStatus.Recognizing:
+                case SpeechToTextStatus.Recognized:
+                    if (e.text) {
+                        const startsWithAgent = e.text.startsWith(VoiceChatService_1.PHRASES_UPPER[VoiceChatService_1.AGENT_PREFIX]) || e.text.startsWith(VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]);
+                        const startsWithSlashCommand = e.text.startsWith(VoiceChatService_1.PHRASES_UPPER[VoiceChatService_1.COMMAND_PREFIX]) || e.text.startsWith(VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.COMMAND_PREFIX]);
+                        if (startsWithAgent || startsWithSlashCommand) {
+                            const originalWords = e.text.split(' ');
+                            let transformedWords;
+                            let waitingForInput = false;
+                            if (options.usesAgents && startsWithAgent && !detectedAgent && !detectedSlashCommand && originalWords.length >= 4) {
+                                const phrase = phrases.get(( originalWords.slice(0, 4).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, PhraseTextType.AGENT_AND_COMMAND), ...originalWords.slice(4)];
+                                    waitingForInput = originalWords.length === 4;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedAgent = true;
+                                        detectedSlashCommand = true;
+                                    }
+                                }
+                            }
+                            if (options.usesAgents && startsWithAgent && !detectedAgent && !transformedWords && originalWords.length >= 2) {
+                                const phrase = phrases.get(( originalWords.slice(0, 2).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, PhraseTextType.AGENT), ...originalWords.slice(2)];
+                                    waitingForInput = originalWords.length === 2;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedAgent = true;
+                                    }
+                                }
+                            }
+                            if (startsWithSlashCommand && !detectedSlashCommand && !transformedWords && originalWords.length >= 2) {
+                                const phrase = phrases.get(( originalWords.slice(0, 2).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, options.usesAgents && !detectedAgent ?
+                                            PhraseTextType.AGENT_AND_COMMAND :
+                                            PhraseTextType.COMMAND
+                                        ), ...originalWords.slice(2)];
+                                    waitingForInput = originalWords.length === 2;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedSlashCommand = true;
+                                    }
+                                }
+                            }
+                            emitter.fire({
+                                status: e.status,
+                                text: (transformedWords ?? originalWords).join(' '),
+                                waitingForInput
+                            });
+                            break;
+                        }
+                    }
+                default:
+                    emitter.fire(e);
+                    break;
+            }
+        }));
+        return {
+            onDidChange: emitter.event
+        };
+    }
+    normalizeWord(word) {
+        word = rtrim(word, '.');
+        word = rtrim(word, ',');
+        word = rtrim(word, '?');
+        return word.toLowerCase();
+    }
+};
+VoiceChatService = VoiceChatService_1 = ( __decorate([
+    ( __param(0, ISpeechService)),
+    ( __param(1, IChatAgentService))
+], VoiceChatService));
+
+export { VoiceChatService };

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

@@ -0,0 +1,40 @@
+import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { InlineAccessibilityHelpContribution, StartSessionAction, CloseAction, ConfigureInlineChatAction, UnstashSessionAction, ReRunRequestAction, ReRunRequestWithIntentDetectionAction, DiscardHunkAction, DiscardAction, DiscardToClipboardAction, DiscardUndoToNewFileAction, CancelSessionAction, MoveToNextHunk, MoveToPreviousHunk, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, ViewInChatAction, ToggleDiffForChange, ReportIssueForBugCommand, AcceptChanges, CopyRecordings } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
+import { INLINE_CHAT_ID, INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import '../common/inlineChatServiceImpl.js';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { InlineChatNotebookContribution } from './inlineChatNotebook.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import './inlineChatSavingServiceImpl.js';
+import { InlineChatAccessibleViewContribution } from './inlineChatAccessibleView.js';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionServiceImpl';
+
+registerEditorContribution(INLINE_CHAT_ID, InlineChatController, 0 );
+registerEditorContribution(INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID, InlineAccessibilityHelpContribution, 3 );
+registerAction2(StartSessionAction);
+registerAction2(CloseAction);
+registerAction2(ConfigureInlineChatAction);
+registerAction2(UnstashSessionAction);
+registerAction2(ReRunRequestAction);
+registerAction2(ReRunRequestWithIntentDetectionAction);
+registerAction2(DiscardHunkAction);
+registerAction2(DiscardAction);
+registerAction2(DiscardToClipboardAction);
+registerAction2(DiscardUndoToNewFileAction);
+registerAction2(CancelSessionAction);
+registerAction2(MoveToNextHunk);
+registerAction2(MoveToPreviousHunk);
+registerAction2(ArrowOutUpAction);
+registerAction2(ArrowOutDownAction);
+registerAction2(FocusInlineChat);
+registerAction2(ViewInChatAction);
+registerAction2(ToggleDiffForChange);
+registerAction2(ReportIssueForBugCommand);
+registerAction2(AcceptChanges);
+registerAction2(CopyRecordings);
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatNotebookContribution, 3 );
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatAccessibleViewContribution, 4 );

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

@@ -0,0 +1,41 @@
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { AccessibleViewAction } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleViewActions';
+
+class InlineChatAccessibleViewContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibleViewAction.addImplementation(100, 'inlineChat', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const codeEditorService = accessor.get(ICodeEditorService);
+            const editor = (codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor());
+            if (!editor) {
+                return false;
+            }
+            const controller = InlineChatController.get(editor);
+            if (!controller) {
+                return false;
+            }
+            const responseContent = controller?.getMessage();
+            if (!responseContent) {
+                return false;
+            }
+            accessibleViewService.show({
+                id: "inlineChat" ,
+                verbositySettingKey: "accessibility.verbosity.inlineChat" ,
+                provideContent() { return responseContent; },
+                onClose() {
+                    controller.focus();
+                },
+                options: { type: "view"  }
+            });
+            return true;
+        }, ( ContextKeyExpr.or(CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED))));
+    }
+}
+
+export { InlineChatAccessibleViewContribution };

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

@@ -0,0 +1,72 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { illegalState } from 'vscode/vscode/vs/base/common/errors';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+let InlineChatNotebookContribution = class InlineChatNotebookContribution {
+    constructor(sessionService, notebookEditorService) {
+        this._store = ( new DisposableStore());
+        this._store.add(sessionService.registerSessionKeyComputer(Schemas.vscodeNotebookCell, {
+            getComparisonKey: (editor, uri) => {
+                const data = CellUri.parse(uri);
+                if (!data) {
+                    throw illegalState('Expected notebook cell uri');
+                }
+                let fallback;
+                for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
+                    if (notebookEditor.hasModel() && isEqual(notebookEditor.textModel.uri, data.notebook)) {
+                        const candidate = `<notebook>${notebookEditor.getId()}#${uri}`;
+                        if (!fallback) {
+                            fallback = candidate;
+                        }
+                        if (notebookEditor.codeEditors.find((tuple) => tuple[1] === editor)) {
+                            return candidate;
+                        }
+                    }
+                }
+                if (fallback) {
+                    return fallback;
+                }
+                throw illegalState('Expected notebook editor');
+            }
+        }));
+        this._store.add(sessionService.onWillStartSession(newSessionEditor => {
+            const candidate = CellUri.parse(newSessionEditor.getModel().uri);
+            if (!candidate) {
+                return;
+            }
+            for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
+                if (isEqual(notebookEditor.textModel?.uri, candidate.notebook)) {
+                    let found = false;
+                    const editors = [];
+                    for (const [, codeEditor] of notebookEditor.codeEditors) {
+                        editors.push(codeEditor);
+                        found = codeEditor === newSessionEditor || found;
+                    }
+                    if (found) {
+                        for (const editor of editors) {
+                            if (editor !== newSessionEditor) {
+                                InlineChatController.get(editor)?.finishExistingSession();
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+InlineChatNotebookContribution = ( __decorate([
+    ( __param(0, IInlineChatSessionService)),
+    ( __param(1, INotebookEditorService))
+], InlineChatNotebookContribution));
+
+export { InlineChatNotebookContribution };

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

@@ -0,0 +1,236 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Queue, raceCancellation } from 'vscode/vscode/vs/base/common/async';
+import { DisposableStore, MutableDisposable, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { compare } from 'vscode/vscode/vs/base/common/strings';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+
+let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
+    constructor(_fileConfigService, _editorGroupService, _textFileService, _editorService, _inlineChatSessionService, _configService, _workingCopyFileService, _logService) {
+        this._fileConfigService = _fileConfigService;
+        this._editorGroupService = _editorGroupService;
+        this._textFileService = _textFileService;
+        this._editorService = _editorService;
+        this._inlineChatSessionService = _inlineChatSessionService;
+        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.add(Event.any(_inlineChatSessionService.onDidEndSession, _inlineChatSessionService.onDidStashSession)(e => {
+            this._sessionData.get(e.session)?.dispose();
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+        dispose(( this._sessionData.values()));
+    }
+    markChanged(session) {
+        if (!( this._sessionData.has(session))) {
+            let uri = session.targetUri;
+            if (uri.scheme === Schemas.vscodeNotebookCell) {
+                const data = CellUri.parse(uri);
+                if (!data) {
+                    return;
+                }
+                uri = data?.notebook;
+            }
+            if (this._sessionData.size === 0) {
+                this._installSaveParticpant();
+            }
+            const saveConfigOverride = this._fileConfigService.disableAutoSave(uri);
+            this._sessionData.set(session, {
+                resourceUri: uri,
+                groupCandidate: this._editorGroupService.activeGroup,
+                session,
+                dispose: () => {
+                    saveConfigOverride.dispose();
+                    this._sessionData.delete(session);
+                    if (this._sessionData.size === 0) {
+                        this._saveParticipant.clear();
+                    }
+                }
+            });
+        }
+    }
+    _installSaveParticpant() {
+        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));
+            }
+        });
+        const d2 = this._workingCopyFileService.addSaveParticipant({
+            participate: (workingCopy, ctx, progress, token) => {
+                return queue.queue(() => this._participate(ctx.savedFrom ?? workingCopy.resource, ctx.reason, progress, token));
+            }
+        });
+        this._saveParticipant.value = combinedDisposable(d1, d2, queue);
+    }
+    async _participate(uri, reason, progress, token) {
+        if (reason !== 1 ) {
+            return;
+        }
+        if (!this._configService.getValue("inlineChat.acceptedOrDiscardBeforeSave" )) {
+            return;
+        }
+        const sessions = ( new Map());
+        for (const [session, data] of this._sessionData) {
+            if (uri?.toString() === ( data.resourceUri.toString())) {
+                sessions.set(session, data);
+            }
+        }
+        if (sessions.size === 0) {
+            return;
+        }
+        progress.report({
+            message: sessions.size === 1
+                ? ( localizeWithPath(
+                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
+                'inlineChat',
+                "Waiting for Inline Chat changes to be Accepted or Discarded..."
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
+                'inlineChat.N',
+                "Waiting for Inline Chat changes in {0} editors to be Accepted or Discarded...",
+                sessions.size
+            ))
+        });
+        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);
+        });
+        const allSessionsEnded = this._whenSessionsEnded(Iterable.concat(( groups.map(tuple => tuple[1])), orphans), token);
+        await Promise.race([allSessionsEnded, editorsOpenedAndSessionsEnded]);
+    }
+    _getGroupsAndOrphans(sessions) {
+        const groupByEditor = ( new Map());
+        for (const group of this._editorGroupService.getGroups(1 )) {
+            const candidate = group.activeEditorPane?.getControl();
+            if (isCodeEditor(candidate)) {
+                groupByEditor.set(candidate, group);
+            }
+        }
+        const groups = [];
+        const orphans = ( new Set());
+        for (const data of sessions) {
+            const editor = this._inlineChatSessionService.getCodeEditor(data.session);
+            const group = groupByEditor.get(editor);
+            if (group) {
+                groups.push([group, data]);
+            }
+            else if (this._editorGroupService.groups.includes(data.groupCandidate)) {
+                groups.push([data.groupCandidate, data]);
+            }
+            else {
+                orphans.add(data);
+            }
+        }
+        return { groups, orphans };
+    }
+    async _openAndWait(groups, token) {
+        const dataByGroup = ( new Map());
+        for (const [group, data] of groups) {
+            let array = dataByGroup.get(group);
+            if (!array) {
+                array = [];
+                dataByGroup.set(group, array);
+            }
+            array.push(data);
+        }
+        for (const [group, array] of dataByGroup) {
+            if (token.isCancellationRequested) {
+                break;
+            }
+            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);
+                let editor;
+                if (data.session.targetUri.scheme === Schemas.vscodeNotebookCell) {
+                    const notebookEditor = getNotebookEditorFromEditorPane(pane);
+                    const uriData = CellUri.parse(data.session.targetUri);
+                    if (notebookEditor && notebookEditor.hasModel() && uriData) {
+                        const cell = notebookEditor.getCellByHandle(uriData.handle);
+                        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()));
+                        editor = tuple?.[1];
+                    }
+                }
+                else {
+                    if (isCodeEditor(pane?.getControl())) {
+                        editor = pane.getControl();
+                    }
+                }
+                if (!editor) {
+                    break;
+                }
+                this._inlineChatSessionService.moveSession(data.session, editor);
+                InlineChatController.get(editor)?.showSaveHint();
+                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());
+        for (const item of iterable) {
+            sessions.set(item.session, item);
+        }
+        if (sessions.size === 0) {
+            return;
+        }
+        let listener;
+        const whenEnded = ( new Promise(resolve => {
+            listener = Event.any(this._inlineChatSessionService.onDidEndSession, this._inlineChatSessionService.onDidStashSession)(e => {
+                const data = sessions.get(e.session);
+                if (data) {
+                    data.dispose();
+                    sessions.delete(e.session);
+                    if (sessions.size === 0) {
+                        resolve();
+                    }
+                }
+            });
+        }));
+        try {
+            await raceCancellation(whenEnded, token);
+        }
+        finally {
+            listener?.dispose();
+        }
+    }
+};
+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 };

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChatServiceImpl.js

@@ -0,0 +1,33 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { LinkedList } from 'vscode/vscode/vs/base/common/linkedList';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { CTX_INLINE_CHAT_HAS_PROVIDER } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+
+let InlineChatServiceImpl = class InlineChatServiceImpl {
+    constructor(contextKeyService) {
+        this._onDidChangeProviders = ( new Emitter());
+        this._entries = ( new LinkedList());
+        this.onDidChangeProviders = this._onDidChangeProviders.event;
+        this._ctxHasProvider = CTX_INLINE_CHAT_HAS_PROVIDER.bindTo(contextKeyService);
+    }
+    addProvider(provider) {
+        const rm = this._entries.push(provider);
+        this._ctxHasProvider.set(true);
+        this._onDidChangeProviders.fire({ added: provider });
+        return toDisposable(() => {
+            rm();
+            this._ctxHasProvider.set(this._entries.size > 0);
+            this._onDidChangeProviders.fire({ removed: provider });
+        });
+    }
+    getAllProvider() {
+        return [...this._entries].reverse();
+    }
+};
+InlineChatServiceImpl = ( __decorate([
+    ( __param(0, IContextKeyService))
+], InlineChatServiceImpl));
+
+export { InlineChatServiceImpl };