@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -9,29 +9,48 @@ import { IExtensionManagementService } from '@codingame/monaco-vscode-api/vscode
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 
 var ChatGettingStartedContribution_1;
 let ChatGettingStartedContribution = class ChatGettingStartedContribution extends Disposable {
-    static { ChatGettingStartedContribution_1 = this; }
-    static { this.ID = 'workbench.contrib.chatGettingStarted'; }
-    static { this.hideWelcomeView = 'workbench.chat.hideWelcomeView'; }
-    constructor(productService, extensionService, extensionManagementService, storageService, chatWidgetService) {
+    static {
+        ChatGettingStartedContribution_1 = this;
+    }
+    static {
+        this.ID = "workbench.contrib.chatGettingStarted";
+    }
+    static {
+        this.hideWelcomeView = "workbench.chat.hideWelcomeView";
+    }
+    constructor(
+        productService,
+        extensionService,
+        extensionManagementService,
+        storageService,
+        chatWidgetService,
+        configurationService
+    ) {
         super();
         this.productService = productService;
         this.extensionService = extensionService;
         this.extensionManagementService = extensionManagementService;
         this.storageService = storageService;
         this.chatWidgetService = chatWidgetService;
+        this.configurationService = configurationService;
         this.recentlyInstalled = false;
         const defaultChatAgent = this.productService.defaultChatAgent;
-        const hideWelcomeView = this.storageService.getBoolean(ChatGettingStartedContribution_1.hideWelcomeView, StorageScope.APPLICATION, false);
+        const hideWelcomeView = this.storageService.getBoolean(
+            ChatGettingStartedContribution_1.hideWelcomeView,
+            StorageScope.APPLICATION,
+            false
+        );
         if (!defaultChatAgent || hideWelcomeView) {
             return;
         }
         this.registerListeners(defaultChatAgent);
     }
     registerListeners(defaultChatAgent) {
-        this._register(this.extensionManagementService.onDidInstallExtensions(async (result) => {
+        this._register(this.extensionManagementService.onDidInstallExtensions(async result => {
             for (const e of result) {
                 if (ExtensionIdentifier.equals(defaultChatAgent.extensionId, e.identifier.id) && e.operation === InstallOperation.Install) {
                     this.recentlyInstalled = true;
@@ -39,7 +58,7 @@ let ChatGettingStartedContribution = class ChatGettingStartedContribution extend
                 }
             }
         }));
-        this._register(this.extensionService.onDidChangeExtensionsStatus(async (event) => {
+        this._register(this.extensionService.onDidChangeExtensionsStatus(async event => {
             for (const ext of event) {
                 if (ExtensionIdentifier.equals(defaultChatAgent.extensionId, ext.value)) {
                     const extensionStatus = this.extensionService.getExtensionsStatus();
@@ -52,17 +71,19 @@ let ChatGettingStartedContribution = class ChatGettingStartedContribution extend
         }));
     }
     async onDidInstallChat() {
-        this.chatWidgetService.revealWidget();
-        this.storageService.store(ChatGettingStartedContribution_1.hideWelcomeView, true, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        const startupEditor = this.configurationService.getValue("workbench.startupEditor");
+        if (startupEditor !== "agentSessionsWelcomePage") {
+            this.chatWidgetService.revealWidget();
+        }
+        this.storageService.store(
+            ChatGettingStartedContribution_1.hideWelcomeView,
+            true,
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
         this.recentlyInstalled = false;
     }
 };
-ChatGettingStartedContribution = ChatGettingStartedContribution_1 = ( __decorate([
-    ( __param(0, IProductService)),
-    ( __param(1, IExtensionService)),
-    ( __param(2, IExtensionManagementService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IChatWidgetService))
-], ChatGettingStartedContribution));
+ChatGettingStartedContribution = ChatGettingStartedContribution_1 = ( __decorate([( __param(0, IProductService)), ( __param(1, IExtensionService)), ( __param(2, IExtensionManagementService)), ( __param(3, IStorageService)), ( __param(4, IChatWidgetService)), ( __param(5, IConfigurationService))], ChatGettingStartedContribution));
 
 export { ChatGettingStartedContribution };

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

@@ -1 +1,12 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/**
+ * Target location for importing a chat session.
+ * - 'chatViewPane': Opens in the chat view pane (sidebar/panel)
+ * - 'default': Opens in the active editor group
+ */
+export type ChatImportTarget = "chatViewPane" | "default";
+export interface ChatImportOptions {
+    inputPath?: URI;
+    target?: ChatImportTarget;
+}
 export declare function registerChatExportActions(): void;

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

@@ -6,6 +6,7 @@ import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs
 import { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
@@ -13,17 +14,20 @@ import { isExportableSessionData } from '@codingame/monaco-vscode-api/vscode/vs/
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
 
-const defaultFileName = 'chat.json';
-const filters = [{ name: ( localize(4762, "Chat Session")), extensions: ['json'] }];
+const defaultFileName = "chat.json";
+const filters = [{
+    name: ( localize(4802, "Chat Session")),
+    extensions: ["json"]
+}];
 function registerChatExportActions() {
     registerAction2(class ExportChatAction extends Action2 {
         constructor() {
             super({
-                id: 'workbench.action.chat.export',
+                id: "workbench.action.chat.export",
                 category: CHAT_CATEGORY,
-                title: ( localize2(4763, "Export Chat...")),
+                title: ( localize2(4803, "Export Chat...")),
                 precondition: ChatContextKeys.enabled,
-                f1: true,
+                f1: true
             });
         }
         async run(accessor, outputPath) {
@@ -57,36 +61,62 @@ function registerChatExportActions() {
     registerAction2(class ImportChatAction extends Action2 {
         constructor() {
             super({
-                id: 'workbench.action.chat.import',
-                title: ( localize2(4764, "Import Chat...")),
+                id: "workbench.action.chat.import",
+                title: ( localize2(4804, "Import Chat...")),
                 category: CHAT_CATEGORY,
                 precondition: ChatContextKeys.enabled,
-                f1: true,
+                f1: true
             });
         }
-        async run(accessor, ...args) {
-            const fileDialogService = accessor.get(IFileDialogService);
+        async run(accessor, opts) {
             const fileService = accessor.get(IFileService);
             const widgetService = accessor.get(IChatWidgetService);
-            const defaultUri = joinPath(await fileDialogService.defaultFilePath(), defaultFileName);
-            const result = await fileDialogService.showOpenDialog({
-                defaultUri,
-                canSelectFiles: true,
-                filters
-            });
-            if (!result) {
-                return;
+            const chatService = accessor.get(IChatService);
+            const fileDialogService = accessor.get(IFileDialogService);
+            let inputPath = opts?.inputPath;
+            if (!inputPath) {
+                const defaultUri = joinPath(await fileDialogService.defaultFilePath(), defaultFileName);
+                const result = await fileDialogService.showOpenDialog({
+                    defaultUri,
+                    canSelectFiles: true,
+                    filters
+                });
+                if (!result) {
+                    return;
+                }
+                inputPath = result[0];
             }
-            const content = await fileService.readFile(result[0]);
+            const content = await fileService.readFile(inputPath);
             try {
                 const data = revive(JSON.parse(( content.value.toString())));
                 if (!isExportableSessionData(data)) {
-                    throw ( new Error('Invalid chat session data'));
+                    throw ( new Error("Invalid chat session data"));
                 }
-                const options = { target: { data }, pinned: true };
-                await widgetService.openSession(ChatEditorInput.getNewEditorUri(), undefined, options);
-            }
-            catch (err) {
+                let sessionResource;
+                let resolvedTarget;
+                let options;
+                if (opts?.target === "chatViewPane") {
+                    const modelRef = chatService.loadSessionFromContent(data);
+                    if (!modelRef) {
+                        return;
+                    }
+                    sessionResource = modelRef.object.sessionResource;
+                    resolvedTarget = ChatViewPaneTarget;
+                    options = {
+                        pinned: true
+                    };
+                } else {
+                    sessionResource = ChatEditorInput.getNewEditorUri();
+                    resolvedTarget = undefined;
+                    options = {
+                        target: {
+                            data
+                        },
+                        pinned: true
+                    };
+                }
+                await widgetService.openSession(sessionResource, resolvedTarget, options);
+            } catch (err) {
                 throw err;
             }
         }

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

@@ -15,17 +15,19 @@ import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/th
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
 
 class ManageLanguageModelAuthenticationAction extends Action2 {
-    static { this.ID = 'workbench.action.chat.manageLanguageModelAuthentication'; }
+    static {
+        this.ID = "workbench.action.chat.manageLanguageModelAuthentication";
+    }
     constructor() {
         super({
             id: ManageLanguageModelAuthenticationAction.ID,
-            title: ( localize2(4765, 'Manage Language Model Access...')),
+            title: ( localize2(4805, "Manage Language Model Access...")),
             category: CHAT_CATEGORY,
             precondition: ChatContextKeys.enabled,
             menu: [{
-                    id: MenuId.AccountsContext,
-                    order: 100,
-                }],
+                id: MenuId.AccountsContext,
+                order: 100
+            }],
             f1: true
         });
     }
@@ -51,7 +53,7 @@ class ManageLanguageModelAuthenticationAction extends Action2 {
             }
             try {
                 const providerId = INTERNAL_AUTH_PROVIDER_PREFIX + ownerId;
-                const accountLabel = model.auth.accountLabel || 'Language Models';
+                const accountLabel = model.auth.accountLabel || "Language Models";
                 ownerToAccountLabel.set(ownerId, accountLabel);
                 const allowedExtensions = authenticationAccessService.readAllowedExtensions(providerId, accountLabel).filter(ext => !ext.trusted);
                 if (productService.trustedExtensionAuthAccess && !Array.isArray(productService.trustedExtensionAuthAccess)) {
@@ -80,8 +82,7 @@ class ManageLanguageModelAuthenticationAction extends Action2 {
                     }
                 }
                 extensionAuth.set(ownerId, filteredExtensions);
-            }
-            catch (error) {
+            } catch (error) {
                 if (!( extensionAuth.has(ownerId))) {
                     extensionAuth.set(ownerId, []);
                 }
@@ -89,11 +90,11 @@ class ManageLanguageModelAuthenticationAction extends Action2 {
         }
         if (extensionAuth.size === 0) {
             dialogService.prompt({
-                type: 'info',
-                message: ( localize(4766, 'No language models requiring authentication found.')),
+                type: "info",
+                message: ( localize(4806, "No language models requiring authentication found.")),
                 detail: ( localize(
-                    4767,
-                    'There are currently no language models that require authentication.'
+                    4807,
+                    "There are currently no language models that require authentication."
                 ))
             });
             return;
@@ -105,21 +106,21 @@ class ManageLanguageModelAuthenticationAction extends Action2 {
                 continue;
             }
             items.push({
-                type: 'separator',
+                type: "separator",
                 id: ownerId,
-                label: ( localize(4768, '{0}', extension.displayName || extension.name)),
+                label: ( localize(4808, "{0}", extension.displayName || extension.name)),
                 buttons: [{
-                        iconClass: ThemeIcon.asClassName(Codicon.info),
-                        tooltip: ( localize(4769, 'Open Extension')),
-                    }]
+                    iconClass: ThemeIcon.asClassName(Codicon.info),
+                    tooltip: ( localize(4809, "Open Extension"))
+                }]
             });
             let addedTrustedSeparator = false;
             if (allowedExtensions.length > 0) {
                 for (const allowedExt of allowedExtensions) {
                     if (allowedExt.trusted && !addedTrustedSeparator) {
                         items.push({
-                            type: 'separator',
-                            label: ( localize(4770, 'Trusted by Microsoft')),
+                            type: "separator",
+                            label: ( localize(4810, "Trusted by Microsoft"))
                         });
                         addedTrustedSeparator = true;
                     }
@@ -131,18 +132,17 @@ class ManageLanguageModelAuthenticationAction extends Action2 {
                         extension: allowedExt,
                         disabled: allowedExt.trusted,
                         buttons: [{
-                                iconClass: ThemeIcon.asClassName(Codicon.info),
-                                tooltip: ( localize(4769, 'Open Extension')),
-                            }]
+                            iconClass: ThemeIcon.asClassName(Codicon.info),
+                            tooltip: ( localize(4809, "Open Extension"))
+                        }]
                     });
                 }
-            }
-            else {
+            } else {
                 items.push({
-                    label: ( localize(4771, 'No extensions have access')),
+                    label: ( localize(4811, "No extensions have access")),
                     description: ( localize(
-                        4772,
-                        'No extensions are currently allowed to use models from {0}',
+                        4812,
+                        "No extensions are currently allowed to use models from {0}",
                         ownerId
                     )),
                     pickable: false
@@ -164,26 +164,65 @@ class ManageLanguageModelAuthenticationAction extends Action2 {
                     void extensionsWorkbenchService.open(extId);
                 }
             },
-            title: ( localize(4773, 'Manage Language Model Access')),
-            placeHolder: ( localize(4774, 'Choose which extensions can access language models')),
+            title: ( localize(4813, "Manage Language Model Access")),
+            placeHolder: ( localize(4814, "Choose which extensions can access language models"))
         });
         if (!result) {
             return;
         }
         for (const [ownerId, allowedExtensions] of extensionAuth) {
-            const allowedSet = ( new Set(( result
-                .filter(item => item.ownerId === ownerId)
-                .filter(item => !item.extension?.trusted)
-                .map(item => item.id))));
+            const allowedSet = ( new Set((
+            result.filter(item => item.ownerId === ownerId).filter(item => !item.extension?.trusted).map(item => item.id))));
             for (const allowedExt of allowedExtensions) {
                 allowedExt.allowed = ( allowedSet.has(allowedExt.id));
             }
-            authenticationAccessService.updateAllowedExtensions(INTERNAL_AUTH_PROVIDER_PREFIX + ownerId, ownerToAccountLabel.get(ownerId) || 'Language Models', allowedExtensions);
+            authenticationAccessService.updateAllowedExtensions(
+                INTERNAL_AUTH_PROVIDER_PREFIX + ownerId,
+                ownerToAccountLabel.get(ownerId) || "Language Models",
+                allowedExtensions
+            );
+        }
+    }
+}
+class ConfigureLanguageModelsGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: "lm.addLanguageModelsProviderGroup",
+            title: ( localize(4815, "Add Language Models Group"))
+        });
+    }
+    async run(accessor, languageModelsProviderGroup) {
+        const languageModelsService = accessor.get(ILanguageModelsService);
+        if (!languageModelsProviderGroup) {
+            throw ( new Error("Language model group is required"));
+        }
+        const {
+            name,
+            vendor,
+            ...configuration
+        } = languageModelsProviderGroup;
+        await languageModelsService.addLanguageModelsProviderGroup(name, vendor, configuration);
+    }
+}
+class MigrateLanguageModelsGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: "lm.migrateLanguageModelsProviderGroup",
+            title: ( localize(4816, "Migrate Language Models Group"))
+        });
+    }
+    async run(accessor, languageModelsProviderGroup) {
+        const languageModelsService = accessor.get(ILanguageModelsService);
+        if (!languageModelsProviderGroup) {
+            throw ( new Error("Language model group is required"));
         }
+        await languageModelsService.migrateLanguageModelsProviderGroup(languageModelsProviderGroup);
     }
 }
 function registerLanguageModelActions() {
     registerAction2(ManageLanguageModelAuthenticationAction);
+    registerAction2(ConfigureLanguageModelsGroupAction);
+    registerAction2(MigrateLanguageModelsGroupAction);
 }
 
 export { registerLanguageModelActions };

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

@@ -19,7 +19,7 @@ import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 
 var MoveToNewLocation;
-(function (MoveToNewLocation) {
+(function(MoveToNewLocation) {
     MoveToNewLocation["Editor"] = "Editor";
     MoveToNewLocation["Window"] = "Window";
 })(MoveToNewLocation || (MoveToNewLocation = {}));
@@ -27,50 +27,58 @@ function registerMoveActions() {
     registerAction2(class GlobalMoveToEditorAction extends Action2 {
         constructor() {
             super({
-                id: 'workbench.action.chat.openInEditor',
-                title: ( localize2(4775, "Move Chat into Editor Area")),
+                id: "workbench.action.chat.openInEditor",
+                title: ( localize2(4817, "Move Chat into Editor Area")),
                 category: CHAT_CATEGORY,
                 precondition: ChatContextKeys.enabled,
                 f1: true,
                 menu: {
                     id: MenuId.ViewTitle,
-                    when: ( ContextKeyExpr.equals('view', ChatViewId)),
+                    when: ( ContextKeyExpr.equals("view", ChatViewId)),
                     order: 0,
-                    group: '1_open'
-                },
+                    group: "1_open"
+                }
             });
         }
         async run(accessor, ...args) {
             const context = args[0];
-            executeMoveToAction(accessor, MoveToNewLocation.Editor, isChatViewTitleActionContext(context) ? context.sessionResource : undefined);
+            executeMoveToAction(
+                accessor,
+                MoveToNewLocation.Editor,
+                isChatViewTitleActionContext(context) ? context.sessionResource : undefined
+            );
         }
     });
     registerAction2(class GlobalMoveToNewWindowAction extends Action2 {
         constructor() {
             super({
-                id: 'workbench.action.chat.openInNewWindow',
-                title: ( localize2(4776, "Move Chat into New Window")),
+                id: "workbench.action.chat.openInNewWindow",
+                title: ( localize2(4818, "Move Chat into New Window")),
                 category: CHAT_CATEGORY,
                 precondition: ChatContextKeys.enabled,
                 f1: true,
                 menu: {
                     id: MenuId.ViewTitle,
-                    when: ( ContextKeyExpr.equals('view', ChatViewId)),
+                    when: ( ContextKeyExpr.equals("view", ChatViewId)),
                     order: 0,
-                    group: '1_open'
-                },
+                    group: "1_open"
+                }
             });
         }
         async run(accessor, ...args) {
             const context = args[0];
-            executeMoveToAction(accessor, MoveToNewLocation.Window, isChatViewTitleActionContext(context) ? context.sessionResource : undefined);
+            executeMoveToAction(
+                accessor,
+                MoveToNewLocation.Window,
+                isChatViewTitleActionContext(context) ? context.sessionResource : undefined
+            );
         }
     });
     registerAction2(class GlobalMoveToSidebarAction extends Action2 {
         constructor() {
             super({
-                id: 'workbench.action.chat.openInSidebar',
-                title: ( localize2(4777, "Move Chat into Side Bar")),
+                id: "workbench.action.chat.openInSidebar",
+                title: ( localize2(4819, "Move Chat into Side Bar")),
                 category: CHAT_CATEGORY,
                 precondition: ChatContextKeys.enabled,
                 f1: true
@@ -82,37 +90,68 @@ function registerMoveActions() {
     });
     function appendOpenChatInViewMenuItem(menuId, title, icon, locationContextKey) {
         MenuRegistry.appendMenuItem(menuId, {
-            command: { id: 'workbench.action.chat.openInSidebar', title, icon },
+            command: {
+                id: "workbench.action.chat.openInSidebar",
+                title,
+                icon
+            },
             when: ( ContextKeyExpr.and(( ActiveEditorContext.isEqualTo(ChatEditorInput.EditorID)), locationContextKey)),
-            group: menuId === MenuId.CompactWindowEditorTitle ? 'navigation' : undefined,
+            group: menuId === MenuId.CompactWindowEditorTitle ? "navigation" : undefined,
             order: 0
         });
     }
     [MenuId.EditorTitle, MenuId.CompactWindowEditorTitle].forEach(id => {
-        appendOpenChatInViewMenuItem(id, ( localize(4778, "Move Chat into Secondary Side Bar")), Codicon.layoutSidebarRightDock, ( ChatContextKeys.panelLocation.isEqualTo(ViewContainerLocation.AuxiliaryBar)));
-        appendOpenChatInViewMenuItem(id, ( localize(4779, "Move Chat into Primary Side Bar")), Codicon.layoutSidebarLeftDock, ( ChatContextKeys.panelLocation.isEqualTo(ViewContainerLocation.Sidebar)));
-        appendOpenChatInViewMenuItem(id, ( localize(4780, "Move Chat into Panel")), Codicon.layoutPanelDock, ( ChatContextKeys.panelLocation.isEqualTo(ViewContainerLocation.Panel)));
+        appendOpenChatInViewMenuItem(id, ( localize(4820, "Move Chat into Secondary Side Bar")), Codicon.layoutSidebarRightDock, ( ChatContextKeys.panelLocation.isEqualTo(ViewContainerLocation.AuxiliaryBar)));
+        appendOpenChatInViewMenuItem(id, ( localize(4821, "Move Chat into Primary Side Bar")), Codicon.layoutSidebarLeftDock, ( ChatContextKeys.panelLocation.isEqualTo(ViewContainerLocation.Sidebar)));
+        appendOpenChatInViewMenuItem(id, ( localize(4822, "Move Chat into Panel")), Codicon.layoutPanelDock, ( ChatContextKeys.panelLocation.isEqualTo(ViewContainerLocation.Panel)));
     });
 }
 async function executeMoveToAction(accessor, moveTo, sessionResource) {
     const widgetService = accessor.get(IChatWidgetService);
-    const auxiliary = { compact: true, bounds: { width: 800, height: 640 } };
-    const widget = (sessionResource ? widgetService.getWidgetBySessionResource(sessionResource) : undefined)
-        ?? widgetService.lastFocusedWidget;
+    const auxiliary = {
+        compact: true,
+        bounds: {
+            width: 800,
+            height: 640
+        }
+    };
+    const widget = (sessionResource ? widgetService.getWidgetBySessionResource(sessionResource) : undefined) ?? widgetService.lastFocusedWidget;
     if (!widget || !widget.viewModel || widget.location !== ChatAgentLocation.Chat) {
-        await widgetService.openSession(ChatEditorInput.getNewEditorUri(), moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP, { pinned: true, auxiliary });
+        await widgetService.openSession(
+            ChatEditorInput.getNewEditorUri(),
+            moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP,
+            {
+                pinned: true,
+                auxiliary
+            }
+        );
         return;
     }
     const existingWidget = widgetService.getWidgetBySessionResource(widget.viewModel.sessionResource);
     if (!existingWidget) {
-        await widgetService.openSession(ChatEditorInput.getNewEditorUri(), moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP, { pinned: true, auxiliary });
+        await widgetService.openSession(
+            ChatEditorInput.getNewEditorUri(),
+            moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP,
+            {
+                pinned: true,
+                auxiliary
+            }
+        );
         return;
     }
     const resourceToOpen = widget.viewModel.sessionResource;
     const modelInputState = existingWidget.getViewState();
     await widget.clear();
-    const options = { pinned: true, modelInputState, auxiliary };
-    await widgetService.openSession(resourceToOpen, moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP, options);
+    const options = {
+        pinned: true,
+        modelInputState,
+        auxiliary
+    };
+    await widgetService.openSession(
+        resourceToOpen,
+        moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP,
+        options
+    );
 }
 async function moveToSidebar(accessor) {
     const viewsService = accessor.get(IViewsService);
@@ -123,14 +162,16 @@ async function moveToSidebar(accessor) {
     let view;
     if (chatEditor instanceof ChatEditor && chatEditorInput instanceof ChatEditorInput && chatEditorInput.sessionResource) {
         const previousViewState = chatEditor.widget.getViewState();
-        await editorService.closeEditor({ editor: chatEditor.input, groupId: editorGroupService.activeGroup.id });
+        await editorService.closeEditor({
+            editor: chatEditor.input,
+            groupId: editorGroupService.activeGroup.id
+        });
         view = await viewsService.openView(ChatViewId);
         const newModel = await view.loadSession(chatEditorInput.sessionResource);
         if (previousViewState && newModel && !newModel.inputModel.state.get()) {
             newModel.inputModel.setState(previousViewState);
         }
-    }
-    else {
+    } else {
         view = await viewsService.openView(ChatViewId);
     }
     view.focus();