@codingame/monaco-vscode-api 13.1.6 → 14.0.0

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

@@ -0,0 +1,521 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { toAction } from '../../../../../base/common/actions.js';
+import { coalesce } from '../../../../../base/common/arrays.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { fromNowByDay } from '../../../../../base/common/date.js';
+import { Event } from '../../../../../base/common/event.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../../base/common/keyCodes.js';
+import { DisposableStore, Disposable, markAsSingleton } from '../../../../../base/common/lifecycle.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { EditorAction2 } from '../../../../../editor/browser/editorExtensions.js';
+import { Position } from '../../../../../editor/common/core/position.js';
+import { SuggestController } from '../../../../../editor/contrib/suggest/browser/suggestController.js';
+import { localize2, localize } from '../../../../../nls.js';
+import { IActionViewItemService } from '../../../../../platform/actions/browser/actionViewItemService.service.js';
+import { DropdownWithPrimaryActionViewItem } from '../../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
+import { Action2, MenuId, MenuRegistry, registerAction2, SubmenuItemAction, MenuItemAction } from '../../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IsWindowsContext, IsLinuxContext } from '../../../../../platform/contextkey/common/contextkeys.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { KeybindingWeight } from '../../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { IOpenerService } from '../../../../../platform/opener/common/opener.service.js';
+import product$1 from '../../../../../platform/product/common/product.js';
+import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.service.js';
+import { ToggleTitleBarConfigAction } from '../../../../browser/parts/titlebar/titlebarActions.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.service.js';
+import { ACTIVE_GROUP } from '../../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
+import { IHostService } from '../../../../services/host/browser/host.service.js';
+import { IViewsService } from '../../../../services/views/common/viewsService.service.js';
+import { EXTENSIONS_CATEGORY } from '../../../extensions/common/extensions.js';
+import { IExtensionsWorkbenchService } from '../../../extensions/common/extensions.service.js';
+import { ChatAgentLocation } from '../../common/chatAgents.js';
+import { IChatAgentService } from '../../common/chatAgents.service.js';
+import { ChatContextKeys } from '../../common/chatContextKeys.js';
+import { extractAgentAndCommand } from '../../common/chatParserTypes.js';
+import { OPEN_CHAT_QUOTA_EXCEEDED_DIALOG, quotaToButtonMessage } from '../chatQuotasService.js';
+import { IChatQuotasService } from '../chatQuotasService.service.js';
+import { IChatService } from '../../common/chatService.service.js';
+import { IChatVariablesService } from '../../common/chatVariables.service.js';
+import { isRequestVM } from '../../common/chatViewModel.js';
+import { IChatWidgetHistoryService } from '../../common/chatWidgetHistoryService.service.js';
+import { CopilotUsageExtensionFeatureId } from '../../common/languageModelStats.js';
+import { showChatView, ChatViewId } from '../chat.js';
+import { IChatWidgetService } from '../chat.service.js';
+import { ChatEditorInput } from '../chatEditorInput.js';
+import { convertBufferToScreenshotVariable } from '../contrib/screenshot.js';
+import { clearChatEditor } from './chatClear.js';
+
+const CHAT_CATEGORY = ( localize2(4234, 'Chat'));
+const CHAT_OPEN_ACTION_ID = 'workbench.action.chat.open';
+class OpenChatGlobalAction extends Action2 {
+    static { this.TITLE = ( localize2(4235, "Open Chat")); }
+    constructor() {
+        super({
+            id: CHAT_OPEN_ACTION_ID,
+            title: OpenChatGlobalAction.TITLE,
+            icon: Codicon.copilot,
+            f1: true,
+            category: CHAT_CATEGORY,
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.KeyI,
+                mac: {
+                    primary: KeyMod$1.CtrlCmd | KeyMod$1.WinCtrl | KeyCode.KeyI
+                }
+            },
+            menu: {
+                id: MenuId.ChatCommandCenter,
+                group: 'a_open',
+                order: 1
+            }
+        });
+    }
+    async run(accessor, opts) {
+        opts = typeof opts === 'string' ? { query: opts } : opts;
+        const chatService = accessor.get(IChatService);
+        const chatVariablesService = accessor.get(IChatVariablesService);
+        const viewsService = accessor.get(IViewsService);
+        const hostService = accessor.get(IHostService);
+        const chatWidget = await showChatView(viewsService);
+        if (!chatWidget) {
+            return;
+        }
+        if (opts?.previousRequests?.length && chatWidget.viewModel) {
+            for (const { request, response } of opts.previousRequests) {
+                chatService.addCompleteRequest(chatWidget.viewModel.sessionId, request, undefined, 0, { message: response });
+            }
+        }
+        if (opts?.attachScreenshot) {
+            const screenshot = await hostService.getScreenshot();
+            if (screenshot) {
+                chatWidget.attachmentModel.addContext(convertBufferToScreenshotVariable(screenshot));
+            }
+        }
+        if (opts?.query) {
+            if (opts.isPartialQuery) {
+                chatWidget.setInput(opts.query);
+            }
+            else {
+                chatWidget.acceptInput(opts.query);
+            }
+        }
+        if (opts?.variableIds && opts.variableIds.length > 0) {
+            const actualVariables = chatVariablesService.getVariables(ChatAgentLocation.Panel);
+            for (const actualVariable of actualVariables) {
+                if (opts.variableIds.includes(actualVariable.id)) {
+                    chatWidget.attachmentModel.addContext({
+                        range: undefined,
+                        id: actualVariable.id ?? '',
+                        value: undefined,
+                        fullName: actualVariable.fullName,
+                        name: actualVariable.name,
+                        icon: actualVariable.icon
+                    });
+                }
+            }
+        }
+        chatWidget.focusInput();
+    }
+}
+class ChatHistoryAction extends Action2 {
+    constructor() {
+        super({
+            id: `workbench.action.chat.history`,
+            title: ( localize2(4236, "Show Chats...")),
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.equals('view', ChatViewId)),
+                group: 'navigation',
+                order: 2
+            },
+            category: CHAT_CATEGORY,
+            icon: Codicon.history,
+            f1: true,
+            precondition: ChatContextKeys.enabled
+        });
+    }
+    async run(accessor) {
+        const chatService = accessor.get(IChatService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const viewsService = accessor.get(IViewsService);
+        const editorService = accessor.get(IEditorService);
+        const showPicker = () => {
+            const openInEditorButton = {
+                iconClass: ThemeIcon.asClassName(Codicon.file),
+                tooltip: ( localize(4237, "Open in Editor")),
+            };
+            const deleteButton = {
+                iconClass: ThemeIcon.asClassName(Codicon.x),
+                tooltip: ( localize(4238, "Delete")),
+            };
+            const renameButton = {
+                iconClass: ThemeIcon.asClassName(Codicon.pencil),
+                tooltip: ( localize(4239, "Rename")),
+            };
+            const getPicks = () => {
+                const items = chatService.getHistory();
+                items.sort((a, b) => (b.lastMessageDate ?? 0) - (a.lastMessageDate ?? 0));
+                let lastDate = undefined;
+                const picks = items.flatMap((i) => {
+                    const timeAgoStr = fromNowByDay(i.lastMessageDate, true, true);
+                    const separator = timeAgoStr !== lastDate ? {
+                        type: 'separator', label: timeAgoStr,
+                    } : undefined;
+                    lastDate = timeAgoStr;
+                    return [
+                        separator,
+                        {
+                            label: i.title,
+                            description: i.isActive ? `(${( localize(4240, 'current'))})` : '',
+                            chat: i,
+                            buttons: i.isActive ? [renameButton] : [
+                                renameButton,
+                                openInEditorButton,
+                                deleteButton,
+                            ]
+                        }
+                    ];
+                });
+                return coalesce(picks);
+            };
+            const store = ( new DisposableStore());
+            const picker = store.add(quickInputService.createQuickPick({ useSeparators: true }));
+            picker.placeholder = ( localize(4241, "Switch to chat"));
+            const picks = getPicks();
+            picker.items = picks;
+            store.add(picker.onDidTriggerItemButton(async (context) => {
+                if (context.button === openInEditorButton) {
+                    const options = { target: { sessionId: context.item.chat.sessionId }, pinned: true };
+                    editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options }, ACTIVE_GROUP);
+                    picker.hide();
+                }
+                else if (context.button === deleteButton) {
+                    chatService.removeHistoryEntry(context.item.chat.sessionId);
+                    picker.items = getPicks();
+                }
+                else if (context.button === renameButton) {
+                    const title = await quickInputService.input({ title: ( localize(4242, "New chat title")), value: context.item.chat.title });
+                    if (title) {
+                        chatService.setChatSessionTitle(context.item.chat.sessionId, title);
+                    }
+                    showPicker();
+                }
+            }));
+            store.add(picker.onDidAccept(async () => {
+                try {
+                    const item = picker.selectedItems[0];
+                    const sessionId = item.chat.sessionId;
+                    const view = await viewsService.openView(ChatViewId);
+                    view.loadSession(sessionId);
+                }
+                finally {
+                    picker.hide();
+                }
+            }));
+            store.add(picker.onDidHide(() => store.dispose()));
+            picker.show();
+        };
+        showPicker();
+    }
+}
+class OpenChatEditorAction extends Action2 {
+    constructor() {
+        super({
+            id: `workbench.action.openChat`,
+            title: ( localize2(4243, "Open Editor")),
+            f1: true,
+            category: CHAT_CATEGORY,
+            precondition: ChatContextKeys.enabled
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        await editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options: { pinned: true } });
+    }
+}
+class ChatAddAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.addParticipant',
+            title: ( localize2(4244, "Chat with Extension")),
+            icon: Codicon.mention,
+            f1: false,
+            category: CHAT_CATEGORY,
+            menu: {
+                id: MenuId.ChatInput,
+                when: ( ChatContextKeys.location.isEqualTo(ChatAgentLocation.Panel)),
+                group: 'navigation',
+                order: 1
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const widgetService = accessor.get(IChatWidgetService);
+        const context = args[0];
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        if (!widget) {
+            return;
+        }
+        const hasAgentOrCommand = extractAgentAndCommand(widget.parsedInput);
+        if (hasAgentOrCommand?.agentPart || hasAgentOrCommand?.commandPart) {
+            return;
+        }
+        const suggestCtrl = SuggestController.get(widget.inputEditor);
+        if (suggestCtrl) {
+            const curText = widget.inputEditor.getValue();
+            const newValue = curText ? `@ ${curText}` : '@';
+            if (!curText.startsWith('@')) {
+                widget.inputEditor.setValue(newValue);
+            }
+            widget.inputEditor.setPosition(( new Position(1, 2)));
+            suggestCtrl.triggerSuggest(undefined, true);
+        }
+    }
+}
+MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+    command: {
+        id: 'update.showCurrentReleaseNotes',
+        title: ( localize2(4245, "Show Release Notes")),
+    },
+    when: ( ContextKeyExpr.equals('view', ChatViewId))
+});
+function registerChatActions() {
+    registerAction2(OpenChatGlobalAction);
+    registerAction2(ChatHistoryAction);
+    registerAction2(OpenChatEditorAction);
+    registerAction2(ChatAddAction);
+    registerAction2(class ClearChatInputHistoryAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.clearInputHistory',
+                title: ( localize2(4246, "Clear Input History")),
+                precondition: ChatContextKeys.enabled,
+                category: CHAT_CATEGORY,
+                f1: true,
+            });
+        }
+        async run(accessor, ...args) {
+            const historyService = accessor.get(IChatWidgetHistoryService);
+            historyService.clearHistory();
+        }
+    });
+    registerAction2(class ClearChatHistoryAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.clearHistory',
+                title: ( localize2(4247, "Clear All Workspace Chats")),
+                precondition: ChatContextKeys.enabled,
+                category: CHAT_CATEGORY,
+                f1: true,
+            });
+        }
+        async run(accessor, ...args) {
+            const editorGroupsService = accessor.get(IEditorGroupsService);
+            const viewsService = accessor.get(IViewsService);
+            const chatService = accessor.get(IChatService);
+            chatService.clearAllHistoryEntries();
+            const chatView = viewsService.getViewWithId(ChatViewId);
+            if (chatView) {
+                chatView.widget.clear();
+            }
+            editorGroupsService.groups.forEach(group => {
+                group.editors.forEach(editor => {
+                    if (editor instanceof ChatEditorInput) {
+                        clearChatEditor(accessor, editor);
+                    }
+                });
+            });
+        }
+    });
+    registerAction2(class FocusChatAction extends EditorAction2 {
+        constructor() {
+            super({
+                id: 'chat.action.focus',
+                title: ( localize2(4248, 'Focus Chat List')),
+                precondition: ( ContextKeyExpr.and(ChatContextKeys.inChatInput)),
+                category: CHAT_CATEGORY,
+                keybinding: [
+                    {
+                        when: ( ContextKeyExpr.and(ChatContextKeys.inputCursorAtTop, ( ChatContextKeys.inQuickChat.negate()))),
+                        primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow,
+                        weight: KeybindingWeight.EditorContrib,
+                    },
+                    {
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.or(IsWindowsContext, IsLinuxContext)), ( ChatContextKeys.inQuickChat.negate()))),
+                        primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow,
+                        weight: KeybindingWeight.EditorContrib,
+                    },
+                    {
+                        when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ChatContextKeys.inQuickChat)),
+                        primary: KeyMod$1.CtrlCmd | KeyCode.DownArrow,
+                        weight: KeybindingWeight.WorkbenchContrib,
+                    }
+                ]
+            });
+        }
+        runEditorCommand(accessor, editor) {
+            const editorUri = editor.getModel()?.uri;
+            if (editorUri) {
+                const widgetService = accessor.get(IChatWidgetService);
+                widgetService.getWidgetByInputUri(editorUri)?.focusLastMessage();
+            }
+        }
+    });
+    registerAction2(class FocusChatInputAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.focusInput',
+                title: ( localize2(4249, "Focus Chat Input")),
+                f1: false,
+                keybinding: [
+                    {
+                        primary: KeyMod$1.CtrlCmd | KeyCode.DownArrow,
+                        weight: KeybindingWeight.WorkbenchContrib,
+                        when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ( ChatContextKeys.inChatInput.negate()), ( ChatContextKeys.inQuickChat.negate()))),
+                    },
+                    {
+                        when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ( ChatContextKeys.inChatInput.negate()), ChatContextKeys.inQuickChat)),
+                        primary: KeyMod$1.CtrlCmd | KeyCode.UpArrow,
+                        weight: KeybindingWeight.WorkbenchContrib,
+                    }
+                ]
+            });
+        }
+        run(accessor, ...args) {
+            const widgetService = accessor.get(IChatWidgetService);
+            widgetService.lastFocusedWidget?.focusInput();
+        }
+    });
+    function registerOpenLinkAction(id, title, url, order, contextKey = ChatContextKeys.enabled) {
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id,
+                    title,
+                    category: CHAT_CATEGORY,
+                    f1: true,
+                    precondition: contextKey,
+                    menu: {
+                        id: MenuId.ChatCommandCenter,
+                        group: 'y_manage',
+                        order,
+                        when: contextKey
+                    }
+                });
+            }
+            async run(accessor) {
+                const openerService = accessor.get(IOpenerService);
+                openerService.open(( URI.parse(url)));
+            }
+        });
+    }
+    const nonEnterpriseCopilotUsers = ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.notEquals(`config.${defaultChat.providerSetting}`, defaultChat.enterpriseProviderId))));
+    registerOpenLinkAction('workbench.action.chat.managePlan', ( localize2(4250, "Manage Copilot Plan")), defaultChat.managePlanUrl, 1, nonEnterpriseCopilotUsers);
+    registerOpenLinkAction('workbench.action.chat.manageSettings', ( localize2(4251, "Manage Copilot Settings")), defaultChat.manageSettingsUrl, 2, nonEnterpriseCopilotUsers);
+    registerOpenLinkAction('workbench.action.chat.learnMore', ( localize2(4252, "Learn More")), defaultChat.documentationUrl, 3);
+    registerAction2(class ShowExtensionsUsingCopilit extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.showExtensionsUsingCopilot',
+                title: ( localize2(4253, "Show Extensions using Copilot")),
+                f1: true,
+                category: EXTENSIONS_CATEGORY,
+            });
+        }
+        async run(accessor) {
+            const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+            extensionsWorkbenchService.openSearch(`@feature:${CopilotUsageExtensionFeatureId}`);
+        }
+    });
+}
+function stringifyItem(item, includeName = true) {
+    if (isRequestVM(item)) {
+        return (includeName ? `${item.username}: ` : '') + item.messageText;
+    }
+    else {
+        return (includeName ? `${item.username}: ` : '') + ( item.response.toString());
+    }
+}
+const defaultChat = {
+    documentationUrl: product$1.defaultChatAgent?.documentationUrl ?? '',
+    manageSettingsUrl: product$1.defaultChatAgent?.manageSettingsUrl ?? '',
+    managePlanUrl: product$1.defaultChatAgent?.managePlanUrl ?? '',
+    enterpriseProviderId: product$1.defaultChatAgent?.enterpriseProviderId ?? '',
+    providerSetting: product$1.defaultChatAgent?.providerSetting ?? '',
+};
+MenuRegistry.appendMenuItem(MenuId.CommandCenter, {
+    submenu: MenuId.ChatCommandCenter,
+    title: ( localize(4254, "Chat")),
+    icon: Codicon.copilot,
+    when: ( ContextKeyExpr.and(ChatContextKeys.supported, ( ContextKeyExpr.has('config.chat.commandCenter.enabled')))),
+    order: 10001,
+});
+registerAction2(class ToggleCopilotControl extends ToggleTitleBarConfigAction {
+    constructor() {
+        super('chat.commandCenter.enabled', ( localize(4255, 'Copilot Controls')), ( localize(4256, "Toggle visibility of the Copilot Controls in title bar")), 5, false, ( ContextKeyExpr.and(ChatContextKeys.supported, ( ContextKeyExpr.has('config.window.commandCenter')))));
+    }
+});
+let ChatCommandCenterRendering = class ChatCommandCenterRendering extends Disposable {
+    static { this.ID = 'chat.commandCenterRendering'; }
+    constructor(actionViewItemService, agentService, chatQuotasService, instantiationService, contextKeyService) {
+        super();
+        const contextKeySet = ( new Set([ChatContextKeys.Setup.signedOut.key]));
+        const disposable = actionViewItemService.register(MenuId.CommandCenter, MenuId.ChatCommandCenter, (action, options) => {
+            if (!(action instanceof SubmenuItemAction)) {
+                return undefined;
+            }
+            const dropdownAction = toAction({
+                id: 'chat.commandCenter.more',
+                label: ( localize(4257, "More...")),
+                run() { }
+            });
+            const chatExtensionInstalled = ( agentService.getAgents().some(agent => agent.isDefault));
+            const { chatQuotaExceeded, completionsQuotaExceeded } = chatQuotasService.quotas;
+            const signedOut = contextKeyService.getContextKeyValue(ChatContextKeys.Setup.signedOut.key) ?? false;
+            let primaryActionId;
+            let primaryActionTitle;
+            let primaryActionIcon;
+            if (!chatExtensionInstalled) {
+                primaryActionId = 'workbench.action.chat.triggerSetup';
+                primaryActionTitle = ( localize(4258, "Use AI Features with Copilot for Free..."));
+                primaryActionIcon = Codicon.copilot;
+            }
+            else {
+                if (signedOut) {
+                    primaryActionId = CHAT_OPEN_ACTION_ID;
+                    primaryActionTitle = ( localize(4259, "Sign in to Use Copilot..."));
+                    primaryActionIcon = Codicon.copilotWarning;
+                }
+                else if (chatQuotaExceeded || completionsQuotaExceeded) {
+                    primaryActionId = OPEN_CHAT_QUOTA_EXCEEDED_DIALOG;
+                    primaryActionTitle = quotaToButtonMessage({ chatQuotaExceeded, completionsQuotaExceeded });
+                    primaryActionIcon = Codicon.copilotWarning;
+                }
+                else {
+                    primaryActionId = CHAT_OPEN_ACTION_ID;
+                    primaryActionTitle = OpenChatGlobalAction.TITLE.value;
+                    primaryActionIcon = Codicon.copilot;
+                }
+            }
+            return instantiationService.createInstance(DropdownWithPrimaryActionViewItem, instantiationService.createInstance(MenuItemAction, {
+                id: primaryActionId,
+                title: primaryActionTitle,
+                icon: primaryActionIcon,
+            }, undefined, undefined, undefined, undefined), dropdownAction, action.actions, '', { ...options, skipTelemetry: true });
+        }, Event.any(agentService.onDidChangeAgents, chatQuotasService.onDidChangeQuotas, Event.filter(contextKeyService.onDidChangeContext, e => e.affectsSome(contextKeySet))));
+        markAsSingleton(disposable);
+    }
+};
+ChatCommandCenterRendering = ( __decorate([
+    ( __param(0, IActionViewItemService)),
+    ( __param(1, IChatAgentService)),
+    ( __param(2, IChatQuotasService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextKeyService))
+], ChatCommandCenterRendering));
+
+export { CHAT_CATEGORY, CHAT_OPEN_ACTION_ID, ChatCommandCenterRendering, registerChatActions, stringifyItem };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatClear.d.ts

@@ -0,0 +1,3 @@
+import { ServicesAccessor } from "../../../../../platform/instantiation/common/instantiation.js";
+import { ChatEditorInput } from "../chatEditorInput.js";
+export declare function clearChatEditor(accessor: ServicesAccessor, chatEditorInput?: ChatEditorInput): Promise<void>;

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

@@ -0,0 +1,20 @@
+
+import { ChatEditorInput } from '../chatEditorInput.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
+
+async function clearChatEditor(accessor, chatEditorInput) {
+    const editorService = accessor.get(IEditorService);
+    if (!chatEditorInput) {
+        const editorInput = editorService.activeEditor;
+        chatEditorInput = editorInput instanceof ChatEditorInput ? editorInput : undefined;
+    }
+    if (chatEditorInput instanceof ChatEditorInput) {
+        const identifier = editorService.findEditors(chatEditorInput.resource)[0];
+        await editorService.replaceEditors([{
+                editor: chatEditorInput,
+                replacement: { resource: ChatEditorInput.getNewEditorUri(), options: { pinned: true } }
+            }], identifier.groupId);
+    }
+}
+
+export { clearChatEditor };