@codingame/monaco-vscode-chat-service-override 9.0.2 → 10.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/codeBlockOperations.js

@@ -0,0 +1,448 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { AsyncIterableObject } from 'vscode/vscode/vs/base/common/async';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { splitLines } from 'vscode/vscode/vs/base/common/strings';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { ResourceTextEdit, IBulkEditService } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { isLocation } from 'vscode/vscode/vs/editor/common/languages';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
+import { localize } from 'vscode/vscode/vs/nls';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { insertCell } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/cellOperations';
+import { CellKind, NOTEBOOK_EDITOR_ID } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { isResponseVM, isRequestVM } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+
+let InsertCodeBlockOperation = class InsertCodeBlockOperation {
+    constructor(editorService, textFileService, bulkEditService, codeEditorService, chatService, languageService, dialogService) {
+        this.editorService = editorService;
+        this.textFileService = textFileService;
+        this.bulkEditService = bulkEditService;
+        this.codeEditorService = codeEditorService;
+        this.chatService = chatService;
+        this.languageService = languageService;
+        this.dialogService = dialogService;
+    }
+    async run(context) {
+        const activeEditorControl = getEditableActiveCodeEditor(this.editorService);
+        if (activeEditorControl) {
+            await this.handleTextEditor(activeEditorControl, context);
+        }
+        else {
+            const activeNotebookEditor = getActiveNotebookEditor(this.editorService);
+            if (activeNotebookEditor) {
+                await this.handleNotebookEditor(activeNotebookEditor, context);
+            }
+            else {
+                this.notify(( localize(
+                    10728,
+                    "To insert the code block, open a code editor or notebook editor and set the cursor at the location where to insert the code block."
+                )));
+            }
+        }
+        notifyUserAction(this.chatService, context, {
+            kind: 'insert',
+            codeBlockIndex: context.codeBlockIndex,
+            totalCharacters: context.code.length
+        });
+    }
+    async handleNotebookEditor(notebookEditor, codeBlockContext) {
+        if (notebookEditor.isReadOnly) {
+            this.notify(( localize(10729, "Cannot insert the code block to read-only notebook editor.")));
+            return false;
+        }
+        const focusRange = notebookEditor.getFocus();
+        const next = Math.max(focusRange.end - 1, 0);
+        insertCell(this.languageService, notebookEditor, next, CellKind.Code, 'below', codeBlockContext.code, true);
+        return true;
+    }
+    async handleTextEditor(codeEditor, codeBlockContext) {
+        const activeModel = codeEditor.getModel();
+        if (isReadOnly(activeModel, this.textFileService)) {
+            this.notify(( localize(10730, "Cannot insert the code block to read-only code editor.")));
+            return false;
+        }
+        const range = codeEditor.getSelection() ?? ( (new Range(activeModel.getLineCount(), 1, activeModel.getLineCount(), 1)));
+        const text = reindent(codeBlockContext.code, activeModel, range.startLineNumber);
+        const edits = [( (new ResourceTextEdit(activeModel.uri, { range, text })))];
+        await this.bulkEditService.apply(edits);
+        this.codeEditorService.listCodeEditors().find(editor => editor.getModel()?.uri.toString() === ( (activeModel.uri.toString())))?.focus();
+        return true;
+    }
+    notify(message) {
+        this.dialogService.info(message);
+    }
+};
+InsertCodeBlockOperation = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, ITextFileService))),
+    ( (__param(2, IBulkEditService))),
+    ( (__param(3, ICodeEditorService))),
+    ( (__param(4, IChatService))),
+    ( (__param(5, ILanguageService))),
+    ( (__param(6, IDialogService)))
+], InsertCodeBlockOperation)));
+let ApplyCodeBlockOperation = class ApplyCodeBlockOperation {
+    constructor(editorService, textFileService, bulkEditService, codeEditorService, chatService, languageFeaturesService, progressService, languageService, fileService, dialogService, logService) {
+        this.editorService = editorService;
+        this.textFileService = textFileService;
+        this.bulkEditService = bulkEditService;
+        this.codeEditorService = codeEditorService;
+        this.chatService = chatService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.progressService = progressService;
+        this.languageService = languageService;
+        this.fileService = fileService;
+        this.dialogService = dialogService;
+        this.logService = logService;
+    }
+    async run(context) {
+        if (this.inlineChatPreview && this.inlineChatPreview.isOpen()) {
+            await this.dialogService.info(( localize(
+                10731,
+                "Another code change is being previewed. Please apply or discard the pending changes first."
+            )));
+            return;
+        }
+        let activeEditorControl = getEditableActiveCodeEditor(this.editorService);
+        if (context.codemapperUri && !isEqual(activeEditorControl?.getModel().uri, context.codemapperUri)) {
+            try {
+                if (!(await this.fileService.exists(context.codemapperUri))) {
+                    await this.fileService.writeFile(context.codemapperUri, VSBuffer.fromString(''));
+                }
+                await this.editorService.openEditor({ resource: context.codemapperUri });
+                activeEditorControl = getEditableActiveCodeEditor(this.editorService);
+                if (activeEditorControl) {
+                    this.tryToRevealCodeBlock(activeEditorControl, context.code);
+                }
+            }
+            catch (e) {
+                this.logService.info('[ApplyCodeBlockOperation] error opening code mapper file', context.codemapperUri, e);
+            }
+        }
+        let result = undefined;
+        if (activeEditorControl) {
+            await this.handleTextEditor(activeEditorControl, context);
+        }
+        else {
+            const activeNotebookEditor = getActiveNotebookEditor(this.editorService);
+            if (activeNotebookEditor) {
+                result = await this.handleNotebookEditor(activeNotebookEditor, context);
+            }
+            else {
+                this.notify(( localize(10732, "To apply this code block, open a code or notebook editor.")));
+            }
+        }
+        notifyUserAction(this.chatService, context, {
+            kind: 'apply',
+            codeBlockIndex: context.codeBlockIndex,
+            totalCharacters: context.code.length,
+            codeMapper: result?.codeMapper,
+            editsProposed: !!result?.edits,
+        });
+    }
+    async handleNotebookEditor(notebookEditor, codeBlockContext) {
+        if (notebookEditor.isReadOnly) {
+            this.notify(( localize(10733, "Cannot apply code block to read-only notebook editor.")));
+            return undefined;
+        }
+        const focusRange = notebookEditor.getFocus();
+        const next = Math.max(focusRange.end - 1, 0);
+        insertCell(this.languageService, notebookEditor, next, CellKind.Code, 'below', codeBlockContext.code, true);
+        return undefined;
+    }
+    async handleTextEditor(codeEditor, codeBlockContext) {
+        if (isReadOnly(codeEditor.getModel(), this.textFileService)) {
+            this.notify(( localize(10734, "Cannot apply code block to read-only file.")));
+            return undefined;
+        }
+        const result = await this.computeEdits(codeEditor, codeBlockContext);
+        if (result.edits) {
+            const showWithPreview = await this.applyWithInlinePreview(result.edits, codeEditor);
+            if (!showWithPreview) {
+                await this.bulkEditService.apply(result.edits, { showPreview: true });
+                const activeModel = codeEditor.getModel();
+                this.codeEditorService.listCodeEditors().find(editor => editor.getModel()?.uri.toString() === ( (activeModel.uri.toString())))?.focus();
+            }
+        }
+        return result;
+    }
+    async computeEdits(codeEditor, codeBlockActionContext) {
+        const activeModel = codeEditor.getModel();
+        const mappedEditsProviders = this.languageFeaturesService.mappedEditsProvider.ordered(activeModel);
+        if (mappedEditsProviders.length > 0) {
+            const docRefs = [];
+            collectDocumentContextFromSelections(codeEditor, docRefs);
+            collectDocumentContextFromContext(codeBlockActionContext, docRefs);
+            const cancellationTokenSource = ( (new CancellationTokenSource()));
+            let codeMapper;
+            try {
+                const result = await this.progressService.withProgress({ location: 15 , delay: 500, sticky: true, cancellable: true }, async (progress) => {
+                    for (const provider of mappedEditsProviders) {
+                        codeMapper = provider.displayName;
+                        progress.report({ message: ( localize(10735, "Applying code block using {0}...", codeMapper)) });
+                        const mappedEdits = await provider.provideMappedEdits(activeModel, [codeBlockActionContext.code], {
+                            documents: docRefs,
+                            conversation: getChatConversation(codeBlockActionContext),
+                        }, cancellationTokenSource.token);
+                        if (mappedEdits) {
+                            return { edits: mappedEdits.edits, codeMapper };
+                        }
+                    }
+                    return undefined;
+                }, () => cancellationTokenSource.cancel());
+                if (result) {
+                    return result;
+                }
+            }
+            catch (e) {
+                if (!isCancellationError(e)) {
+                    this.notify(( localize(10736, "Failed to apply code block: {0}", e.message)));
+                }
+            }
+            finally {
+                cancellationTokenSource.dispose();
+            }
+            return { edits: [], codeMapper };
+        }
+        return { edits: [], codeMapper: undefined };
+    }
+    async applyWithInlinePreview(edits, codeEditor) {
+        const firstEdit = edits[0];
+        if (!ResourceTextEdit.is(firstEdit)) {
+            return false;
+        }
+        const resource = firstEdit.resource;
+        const textEdits = coalesce(( (edits.map(
+            edit => ResourceTextEdit.is(edit) && isEqual(resource, edit.resource) ? edit.textEdit : undefined
+        ))));
+        if (textEdits.length !== edits.length) {
+            return false;
+        }
+        const editorToApply = await this.codeEditorService.openCodeEditor({ resource }, codeEditor);
+        if (editorToApply) {
+            const inlineChatController = InlineChatController.get(editorToApply);
+            if (inlineChatController) {
+                const tokenSource = ( (new CancellationTokenSource()));
+                let isOpen = true;
+                const firstEdit = textEdits[0];
+                editorToApply.revealLineInCenterIfOutsideViewport(firstEdit.range.startLineNumber);
+                const promise = inlineChatController.reviewEdits(textEdits[0].range, AsyncIterableObject.fromArray(textEdits), tokenSource.token);
+                promise.finally(() => {
+                    isOpen = false;
+                    tokenSource.dispose();
+                });
+                this.inlineChatPreview = {
+                    promise,
+                    isOpen: () => isOpen,
+                    cancel: () => tokenSource.cancel(),
+                };
+                return true;
+            }
+        }
+        return false;
+    }
+    tryToRevealCodeBlock(codeEditor, codeBlock) {
+        const match = codeBlock.match(/(\S[^\n]*)\n/);
+        if (match && match[1].length > 10) {
+            const findMatch = codeEditor.getModel().findNextMatch(match[1], { lineNumber: 1, column: 1 }, false, false, null, false);
+            if (findMatch) {
+                codeEditor.revealRangeInCenter(findMatch.range);
+            }
+        }
+    }
+    notify(message) {
+        this.dialogService.info(message);
+    }
+};
+ApplyCodeBlockOperation = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, ITextFileService))),
+    ( (__param(2, IBulkEditService))),
+    ( (__param(3, ICodeEditorService))),
+    ( (__param(4, IChatService))),
+    ( (__param(5, ILanguageFeaturesService))),
+    ( (__param(6, IProgressService))),
+    ( (__param(7, ILanguageService))),
+    ( (__param(8, IFileService))),
+    ( (__param(9, IDialogService))),
+    ( (__param(10, ILogService)))
+], ApplyCodeBlockOperation)));
+function notifyUserAction(chatService, context, action) {
+    if (isResponseVM(context.element)) {
+        chatService.notifyUserAction({
+            agentId: context.element.agent?.id,
+            command: context.element.slashCommand?.name,
+            sessionId: context.element.sessionId,
+            requestId: context.element.requestId,
+            result: context.element.result,
+            action
+        });
+    }
+}
+function getActiveNotebookEditor(editorService) {
+    const activeEditorPane = editorService.activeEditorPane;
+    if (activeEditorPane?.getId() === NOTEBOOK_EDITOR_ID) {
+        const notebookEditor = activeEditorPane.getControl();
+        if (notebookEditor.hasModel()) {
+            return notebookEditor;
+        }
+    }
+    return undefined;
+}
+function getEditableActiveCodeEditor(editorService) {
+    const activeCodeEditorInNotebook = getActiveNotebookEditor(editorService)?.activeCodeEditor;
+    if (activeCodeEditorInNotebook && activeCodeEditorInNotebook.hasTextFocus() && activeCodeEditorInNotebook.hasModel()) {
+        return activeCodeEditorInNotebook;
+    }
+    let activeEditorControl = editorService.activeTextEditorControl;
+    if (isDiffEditor(activeEditorControl)) {
+        activeEditorControl = activeEditorControl.getOriginalEditor().hasTextFocus() ? activeEditorControl.getOriginalEditor() : activeEditorControl.getModifiedEditor();
+    }
+    if (!isCodeEditor(activeEditorControl)) {
+        return undefined;
+    }
+    if (!activeEditorControl.hasModel()) {
+        return undefined;
+    }
+    return activeEditorControl;
+}
+function isReadOnly(model, textFileService) {
+    const activeTextModel = textFileService.files.get(model.uri) ?? textFileService.untitled.get(model.uri);
+    return !!activeTextModel?.isReadonly();
+}
+function collectDocumentContextFromSelections(codeEditor, result) {
+    const activeModel = codeEditor.getModel();
+    const currentDocUri = activeModel.uri;
+    const currentDocVersion = activeModel.getVersionId();
+    const selections = codeEditor.getSelections();
+    if (selections.length > 0) {
+        result.push([
+            {
+                uri: currentDocUri,
+                version: currentDocVersion,
+                ranges: selections,
+            }
+        ]);
+    }
+}
+function collectDocumentContextFromContext(context, result) {
+    if (isResponseVM(context.element) && context.element.usedContext?.documents) {
+        result.push(context.element.usedContext.documents);
+    }
+}
+function getChatConversation(context) {
+    if (isResponseVM(context.element)) {
+        return [{
+                type: 'response',
+                message: context.element.response.toMarkdown(),
+                references: getReferencesAsDocumentContext(context.element.contentReferences)
+            }];
+    }
+    else if (isRequestVM(context.element)) {
+        return [{
+                type: 'request',
+                message: context.element.messageText,
+            }];
+    }
+    else {
+        return [];
+    }
+}
+function getReferencesAsDocumentContext(res) {
+    const map = ( (new ResourceMap()));
+    for (const r of res) {
+        let uri;
+        let range;
+        if (URI.isUri(r.reference)) {
+            uri = r.reference;
+        }
+        else if (isLocation(r.reference)) {
+            uri = r.reference.uri;
+            range = r.reference.range;
+        }
+        if (uri) {
+            const item = map.get(uri);
+            if (item) {
+                if (range) {
+                    item.ranges.push(range);
+                }
+            }
+            else {
+                map.set(uri, { uri, version: -1, ranges: range ? [range] : [] });
+            }
+        }
+    }
+    return [...( (map.values()))];
+}
+function reindent(codeBlockContent, model, seletionStartLine) {
+    const newContent = splitLines(codeBlockContent);
+    if (newContent.length === 0) {
+        return codeBlockContent;
+    }
+    const formattingOptions = model.getFormattingOptions();
+    const codeIndentLevel = computeIndentation(model.getLineContent(seletionStartLine), formattingOptions.tabSize).level;
+    const indents = ( (newContent.map(line => computeIndentation(line, formattingOptions.tabSize))));
+    const newContentIndentLevel = indents.reduce((min, indent, index) => {
+        if (indent.length !== newContent[index].length) {
+            return Math.min(indent.level, min);
+        }
+        return min;
+    }, Number.MAX_VALUE);
+    if (newContentIndentLevel === Number.MAX_VALUE || newContentIndentLevel === codeIndentLevel) {
+        return codeBlockContent;
+    }
+    const newLines = [];
+    for (let i = 0; i < newContent.length; i++) {
+        const { level, length } = indents[i];
+        const newLevel = Math.max(0, codeIndentLevel + level - newContentIndentLevel);
+        const newIndentation = formattingOptions.insertSpaces ? ' '.repeat(formattingOptions.tabSize * newLevel) : '\t'.repeat(newLevel);
+        newLines.push(newIndentation + newContent[i].substring(length));
+    }
+    return newLines.join('\n');
+}
+function computeIndentation(line, tabSize) {
+    let nSpaces = 0;
+    let level = 0;
+    let i = 0;
+    let length = 0;
+    const len = line.length;
+    while (i < len) {
+        const chCode = line.charCodeAt(i);
+        if (chCode === 32 ) {
+            nSpaces++;
+            if (nSpaces === tabSize) {
+                level++;
+                nSpaces = 0;
+                length = i + 1;
+            }
+        }
+        else if (chCode === 9 ) {
+            level++;
+            nSpaces = 0;
+            length = i + 1;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return { level, length };
+}
+
+export { ApplyCodeBlockOperation, InsertCodeBlockOperation, computeIndentation };

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

@@ -3,19 +3,35 @@ import { isMarkdownString, MarkdownString } from 'vscode/vscode/vs/base/common/h
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { isMacintosh } from 'vscode/vscode/vs/base/common/platform';
+import { registerEditorFeature } from 'vscode/vscode/vs/editor/common/editorFeatures';
 import { localize } from 'vscode/vscode/vs/nls';
 import { AccessibleViewRegistry } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
-import { Extensions as Extensions$1, registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Extensions as Extensions$1, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
 import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService.service';
+import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import 'vscode/vscode/vs/workbench/contrib/chat/common/chatColors';
+import { chatVariableLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import '../common/chatServiceImpl.js';
+import '../common/chatSlashCommands.js';
+import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
+import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
+import '../common/chatWidgetHistoryService.js';
+import '../common/languageModels.js';
+import '../common/languageModelStats.js';
+import '../common/languageModelToolsService.js';
+import { LanguageModelToolsExtensionPointHandler } from '../common/tools/languageModelToolsContribution.js';
+import '../common/voiceChatService.js';
 import { ChatAccessibilityHelp } from './actions/chatAccessibilityHelp.js';
-import { registerChatActions } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ChatCommandCenterRendering, registerChatActions } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 import { ACTION_ID_NEW_CHAT, registerNewChatActions } from './actions/chatClearActions.js';
 import { registerChatCodeBlockActions, registerChatCodeCompareBlockActions } from './actions/chatCodeblockActions.js';
 import { registerChatContextActions } from './actions/chatContextActions.js';
@@ -28,75 +44,71 @@ import { registerMoveActions } from './actions/chatMoveActions.js';
 import { registerQuickChatActions } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatQuickInputActions';
 import { registerChatTitleActions } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatTitleActions';
 import './chatAccessibilityService.js';
+import 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditingService';
 import { ChatEditor } from './chatEditor.js';
 import { ChatEditorInput, ChatEditorInputSerializer } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { ChatGettingStartedContribution } from './chatGettingStarted.js';
 import { agentToMarkdown, agentSlashCommandToMarkdown } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatMarkdownDecorationsRenderer';
 import { ChatExtensionPointHandler, ChatCompatibilityNotifier } from './chatParticipantContributions.js';
+import { ChatPasteProvidersFeature } from './chatPasteProviders.js';
 import './chatQuick.js';
 import { ChatResponseAccessibleView } from './chatResponseAccessibleView.js';
 import './chatVariables.js';
 import 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import './contrib/chatContextAttachments.js';
-import './contrib/chatInputCompletions.js';
+import 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatContextAttachments';
+import 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatInputCompletions';
 import './contrib/chatInputEditorContrib.js';
 import './contrib/chatInputEditorHover.js';
-import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { chatVariableLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import '../common/chatServiceImpl.js';
-import '../common/chatSlashCommands.js';
-import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
-import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
-import '../common/chatWidgetHistoryService.js';
-import 'vscode/vscode/vs/workbench/contrib/chat/common/languageModels';
-import '../common/languageModelStats.js';
-import '../common/languageModelToolsService.js';
-import { LanguageModelToolsExtensionPointHandler } from '../common/tools/languageModelToolsContribution.js';
-import '../common/voiceChatService.js';
-import { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
-import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService.service';
-import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import 'vscode/vscode/vs/workbench/contrib/chat/common/chatColors';
 
 const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
 configurationRegistry.registerConfiguration({
     id: 'chatSidebar',
-    title: ( localize(3062, "Chat")),
+    title: ( localize(3139, "Chat")),
     type: 'object',
     properties: {
         'chat.editor.fontSize': {
             type: 'number',
-            description: ( localize(3063, "Controls the font size in pixels in chat codeblocks.")),
+            description: ( localize(3140, "Controls the font size in pixels in chat codeblocks.")),
             default: isMacintosh ? 12 : 14,
         },
         'chat.editor.fontFamily': {
             type: 'string',
-            description: ( localize(3064, "Controls the font family in chat codeblocks.")),
+            description: ( localize(3141, "Controls the font family in chat codeblocks.")),
             default: 'default'
         },
         'chat.editor.fontWeight': {
             type: 'string',
-            description: ( localize(3065, "Controls the font weight in chat codeblocks.")),
+            description: ( localize(3142, "Controls the font weight in chat codeblocks.")),
             default: 'default'
         },
         'chat.editor.wordWrap': {
             type: 'string',
-            description: ( localize(3066, "Controls whether lines should wrap in chat codeblocks.")),
+            description: ( localize(3143, "Controls whether lines should wrap in chat codeblocks.")),
             default: 'off',
             enum: ['on', 'off']
         },
         'chat.editor.lineHeight': {
             type: 'number',
             description: ( localize(
-                3067,
+                3144,
                 "Controls the line height in pixels in chat codeblocks. Use 0 to compute the line height from the font size."
             )),
             default: 0
         },
+        'chat.commandCenter.enabled': {
+            type: 'boolean',
+            tags: ['experimental'],
+            markdownDescription: ( localize(
+                3145,
+                "Controls whether the command center shows a menu for chat actions (requires {0}).",
+                '`#window.commandCenter#`'
+            )),
+            default: false
+        },
         'chat.experimental.implicitContext': {
             type: 'boolean',
             description: ( localize(
-                3068,
+                3146,
                 "Controls whether a checkbox is shown to allow the user to determine which implicit context is included with a chat participant's prompt."
             )),
             deprecated: true,
@@ -104,27 +116,27 @@ configurationRegistry.registerConfiguration({
         },
         'chat.experimental.variables.editor': {
             type: 'boolean',
-            description: ( localize(3069, "Enables variables for editor chat.")),
+            description: ( localize(3147, "Enables variables for editor chat.")),
             default: true
         },
         'chat.experimental.variables.notebook': {
             type: 'boolean',
-            description: ( localize(3070, "Enables variables for notebook chat.")),
-            default: false
+            description: ( localize(3148, "Enables variables for notebook chat.")),
+            default: true
         },
         'chat.experimental.variables.terminal': {
             type: 'boolean',
-            description: ( localize(3071, "Enables variables for terminal chat.")),
+            description: ( localize(3149, "Enables variables for terminal chat.")),
             default: false
         },
         'chat.experimental.detectParticipant.enabled': {
             type: 'boolean',
-            description: ( localize(3072, "Enables chat participant autodetection for panel chat.")),
+            description: ( localize(3150, "Enables chat participant autodetection for panel chat.")),
             default: null
         },
     }
 });
-( (Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(ChatEditor, ChatEditorInput.EditorID, ( localize(3073, "Chat"))), [
+( (Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(ChatEditor, ChatEditorInput.EditorID, ( localize(3151, "Chat"))), [
     ( (new SyncDescriptor(ChatEditorInput)))
 ]);
 let ChatResolverContribution = class ChatResolverContribution extends Disposable {
@@ -133,7 +145,7 @@ let ChatResolverContribution = class ChatResolverContribution extends Disposable
         super();
         this._register(editorResolverService.registerEditor(`${Schemas.vscodeChatSesssion}:**/**`, {
             id: ChatEditorInput.EditorID,
-            label: ( localize(3073, "Chat")),
+            label: ( localize(3151, "Chat")),
             priority: RegisteredEditorPriority.builtin
         }, {
             singlePerResource: true,
@@ -156,7 +168,7 @@ let ChatSlashStaticSlashCommandsContribution = class ChatSlashStaticSlashCommand
         super();
         this._store.add(slashCommandService.registerSlashCommand({
             command: 'clear',
-            detail: ( localize(3074, "Start a new chat")),
+            detail: ( localize(3152, "Start a new chat")),
             sortText: 'z2_clear',
             executeImmediately: true,
             locations: [ChatAgentLocation.Panel]
@@ -205,7 +217,7 @@ let ChatSlashStaticSlashCommandsContribution = class ChatSlashStaticSlashCommand
                 }
                 const variables = [
                     ...chatVariablesService.getVariables(ChatAgentLocation.Panel),
-                    { name: 'file', description: ( localize(3075, "Choose a file in the workspace")) }
+                    { name: 'file', description: ( localize(3153, "Choose a file in the workspace")) }
                 ];
                 const variableText = ( (variables
                     .map(v => `* \`${chatVariableLeader}${v.name}\` - ${v.description}`)))
@@ -232,12 +244,14 @@ ChatSlashStaticSlashCommandsContribution = ( (__decorate([
     ( (__param(4, IInstantiationService)))
 ], ChatSlashStaticSlashCommandsContribution)));
 const workbenchContributionsRegistry = ( (Registry.as(Extensions$1.Workbench)));
-registerWorkbenchContribution2(ChatResolverContribution.ID, ChatResolverContribution, WorkbenchPhase.BlockStartup);
-workbenchContributionsRegistry.registerWorkbenchContribution(ChatSlashStaticSlashCommandsContribution, LifecyclePhase.Eventually);
+registerWorkbenchContribution2(ChatResolverContribution.ID, ChatResolverContribution, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(ChatSlashStaticSlashCommandsContribution, 4 );
 ( (Registry.as(EditorExtensions.EditorFactory))).registerEditorSerializer(ChatEditorInput.TypeID, ChatEditorInputSerializer);
-registerWorkbenchContribution2(ChatExtensionPointHandler.ID, ChatExtensionPointHandler, WorkbenchPhase.BlockStartup);
-registerWorkbenchContribution2(LanguageModelToolsExtensionPointHandler.ID, LanguageModelToolsExtensionPointHandler, WorkbenchPhase.BlockRestore);
-registerWorkbenchContribution2(ChatCompatibilityNotifier.ID, ChatCompatibilityNotifier, WorkbenchPhase.Eventually);
+registerWorkbenchContribution2(ChatExtensionPointHandler.ID, ChatExtensionPointHandler, 1 );
+registerWorkbenchContribution2(LanguageModelToolsExtensionPointHandler.ID, LanguageModelToolsExtensionPointHandler, 2 );
+registerWorkbenchContribution2(ChatCompatibilityNotifier.ID, ChatCompatibilityNotifier, 4 );
+registerWorkbenchContribution2(ChatGettingStartedContribution.ID, ChatGettingStartedContribution, 4 );
+registerWorkbenchContribution2(ChatCommandCenterRendering.ID, ChatCommandCenterRendering, 3 );
 registerChatActions();
 registerChatCopyActions();
 registerChatCodeBlockActions();
@@ -251,3 +265,4 @@ registerMoveActions();
 registerNewChatActions();
 registerChatContextActions();
 registerChatDeveloperActions();
+registerEditorFeature(ChatPasteProvidersFeature);