@codingame/monaco-vscode-chat-service-override 22.1.8 → 23.0.0

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

@@ -18,7 +18,7 @@ import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/st
 import { equalsIgnoreCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { MarkdownRenderer } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
 import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
@@ -46,7 +46,7 @@ import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
 import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
-import { ProgressBadge } from '@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common/vscode/vs/workbench/services/activity/common/activity';
+import { ProgressBadge } from '@codingame/monaco-vscode-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-common/vscode/vs/workbench/services/activity/common/activity';
 import { IActivityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity.service';
 import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
@@ -68,35 +68,34 @@ import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 import { ChatEntitlement, ChatEntitlementRequests, isProUser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
 import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
-import { ChatRequestModel } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel';
-import { ChatMode } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModes';
-import { ChatRequestToolPart, ChatRequestAgentPart } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatRequestModel } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatMode } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { ChatRequestToolPart, ChatRequestAgentPart } from '@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { ChatConfiguration, ChatAgentLocation, ChatModeKind, validateChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
-import { CHAT_SETUP_ACTION_ID, CHAT_CATEGORY, CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID, CHAT_OPEN_ACTION_ID } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { showCopilotView, ChatViewId } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { CHAT_SETUP_ACTION_ID, CHAT_CATEGORY, CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID, CHAT_OPEN_ACTION_ID } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { showChatView, ChatViewId } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { CHAT_SIDEBAR_PANEL_ID } from './chatViewPane.js';
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
-import { chatViewsWelcomeRegistry } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
+import { chatViewsWelcomeRegistry } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 
-var SetupAgent_1, ChatSetup_1, ChatTeardownContribution_1;
+var SetupAgent_1, DefaultNewSymbolNamesProvider_1, ChatSetup_1, ChatTeardownContribution_1;
 registerCss(chatSetup);
 const defaultChat = {
     extensionId: product.defaultChatAgent?.extensionId ?? '',
     chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
-    documentationUrl: product.defaultChatAgent?.documentationUrl ?? '',
-    skusDocumentationUrl: product.defaultChatAgent?.skusDocumentationUrl ?? '',
     publicCodeMatchesUrl: product.defaultChatAgent?.publicCodeMatchesUrl ?? '',
     manageOveragesUrl: product.defaultChatAgent?.manageOverageUrl ?? '',
     upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',
     provider: product.defaultChatAgent?.provider ?? { default: { id: '', name: '' }, enterprise: { id: '', name: '' }, apple: { id: '', name: '' }, google: { id: '', name: '' } },
     providerUriSetting: product.defaultChatAgent?.providerUriSetting ?? '',
-    providerScopes: product.defaultChatAgent?.providerScopes ?? [[]],
     manageSettingsUrl: product.defaultChatAgent?.manageSettingsUrl ?? '',
     completionsAdvancedSetting: product.defaultChatAgent?.completionsAdvancedSetting ?? '',
-    walkthroughCommand: product.defaultChatAgent?.walkthroughCommand ?? '',
     completionsRefreshTokenCommand: product.defaultChatAgent?.completionsRefreshTokenCommand ?? '',
     chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? '',
     termsStatementUrl: product.defaultChatAgent?.termsStatementUrl ?? '',
@@ -141,31 +140,31 @@ let SetupAgent = class SetupAgent extends Disposable {
                     id = 'setup.notebook';
                     break;
             }
-            return SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, id, `${defaultChat.provider.default.name} Copilot`, true, description, location, mode, context, controller);
+            return SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, id, `${defaultChat.provider.default.name} Copilot` , true, description, location, mode, context, controller);
         });
     }
     static registerBuiltInAgents(instantiationService, context, controller) {
         return instantiationService.invokeFunction(accessor => {
             const chatAgentService = accessor.get(IChatAgentService);
             const disposables = ( new DisposableStore());
-            const { disposable: vscodeDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.vscode', 'vscode', false, ( localize2(5251, "Ask questions about VS Code")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            const { disposable: vscodeDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.vscode', 'vscode', false, ( localize2(5415, "Ask questions about VS Code")).value, ChatAgentLocation.Chat, undefined, context, controller);
             disposables.add(vscodeDisposable);
-            const { disposable: workspaceDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.workspace', 'workspace', false, ( localize2(5252, "Ask about your workspace")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            const { disposable: workspaceDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.workspace', 'workspace', false, ( localize2(5416, "Ask about your workspace")).value, ChatAgentLocation.Chat, undefined, context, controller);
             disposables.add(workspaceDisposable);
-            const { disposable: terminalDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.terminal.agent', 'terminal', false, ( localize2(5253, "Ask how to do something in the terminal")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            const { disposable: terminalDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.terminal.agent', 'terminal', false, ( localize2(5417, "Ask how to do something in the terminal")).value, ChatAgentLocation.Chat, undefined, context, controller);
             disposables.add(terminalDisposable);
             disposables.add(SetupTool.registerTool(instantiationService, {
                 id: 'setup_tools_createNewWorkspace',
                 source: ToolDataSource.Internal,
                 icon: Codicon.newFolder,
-                displayName: ( localize(5254, "New Workspace")),
-                modelDescription: ( localize(5255, "Scaffold a new workspace in VS Code")),
-                userDescription: ( localize(5255, "Scaffold a new workspace in VS Code")),
+                displayName: ( localize(5418, "New Workspace")),
+                modelDescription: ( localize(5419, "Scaffold a new workspace in VS Code")),
+                userDescription: ( localize(5419, "Scaffold a new workspace in VS Code")),
                 canBeReferencedInPrompt: true,
                 toolReferenceName: 'new',
                 when: ContextKeyExpr.true(),
-            }).disposable);
-            return { disposable: disposables };
+            }));
+            return disposables;
         });
     }
     static doRegisterAgent(instantiationService, chatAgentService, id, name, isDefault, description, location, mode, context, controller) {
@@ -194,8 +193,8 @@ let SetupAgent = class SetupAgent extends Disposable {
         }
         return { agent, disposable: disposables };
     }
-    static { this.SETUP_NEEDED_MESSAGE = ( new MarkdownString(( localize(5256, "You need to set up GitHub Copilot and be signed in to use Chat.")))); }
-    static { this.TRUST_NEEDED_MESSAGE = ( new MarkdownString(( localize(5257, "You need to trust this workspace to use Chat.")))); }
+    static { this.SETUP_NEEDED_MESSAGE = ( new MarkdownString(( localize(5420, "You need to set up GitHub Copilot and be signed in to use Chat.")))); }
+    static { this.TRUST_NEEDED_MESSAGE = ( new MarkdownString(( localize(5421, "You need to trust this workspace to use Chat.")))); }
     constructor(context, controller, location, instantiationService, logService, configurationService, telemetryService, environmentService, workspaceTrustManagementService, chatEntitlementService) {
         super();
         this.context = context;
@@ -210,7 +209,7 @@ let SetupAgent = class SetupAgent extends Disposable {
         this.chatEntitlementService = chatEntitlementService;
         this._onUnresolvableError = this._register(( new Emitter()));
         this.onUnresolvableError = this._onUnresolvableError.event;
-        this.pendingForwardedRequests = ( new Map());
+        this.pendingForwardedRequests = ( new ResourceMap());
     }
     async invoke(request, progress) {
         return this.instantiationService.invokeFunction(async (accessor ) => {
@@ -223,7 +222,13 @@ let SetupAgent = class SetupAgent extends Disposable {
         });
     }
     async doInvoke(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
-        if (!this.context.state.installed || this.context.state.disabled || this.context.state.untrusted || this.context.state.entitlement === ChatEntitlement.Available || this.context.state.entitlement === ChatEntitlement.Unknown) {
+        if (!this.context.state.installed ||
+            this.context.state.disabled ||
+            this.context.state.untrusted ||
+            this.context.state.entitlement === ChatEntitlement.Available ||
+            ((
+        this.context.state.entitlement === ChatEntitlement.Unknown && !this.chatEntitlementService.anonymous)
+            )) {
             return this.doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
         }
         return this.doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
@@ -236,49 +241,49 @@ let SetupAgent = class SetupAgent extends Disposable {
         }
         progress({
             kind: 'progressMessage',
-            content: ( new MarkdownString(( localize(5258, "Getting chat ready...")))),
+            content: ( new MarkdownString(( localize(5422, "Getting chat ready...")))),
         });
-        await this.forwardRequestToCopilot(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+        await this.forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
         return {};
     }
-    async forwardRequestToCopilot(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+    async forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
         try {
-            await this.doForwardRequestToCopilot(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+            await this.doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
         }
         catch (error) {
             progress({
                 kind: 'warning',
-                content: ( new MarkdownString(( localize(5259, "Failed to get a response. Please try again."))))
+                content: ( new MarkdownString(( localize(5423, "Failed to get a response. Please try again."))))
             });
         }
     }
-    async doForwardRequestToCopilot(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
-        if (( this.pendingForwardedRequests.has(requestModel.session.sessionId))) {
+    async doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+        if (( this.pendingForwardedRequests.has(requestModel.session.sessionResource))) {
             throw ( new Error('Request already in progress'));
         }
-        const forwardRequest = this.doForwardRequestToCopilotWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
-        this.pendingForwardedRequests.set(requestModel.session.sessionId, forwardRequest);
+        const forwardRequest = this.doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+        this.pendingForwardedRequests.set(requestModel.session.sessionResource, forwardRequest);
         try {
             await forwardRequest;
         }
         finally {
-            this.pendingForwardedRequests.delete(requestModel.session.sessionId);
+            this.pendingForwardedRequests.delete(requestModel.session.sessionResource);
         }
     }
-    async doForwardRequestToCopilotWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
-        const widget = chatWidgetService.getWidgetBySessionId(requestModel.session.sessionId);
+    async doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+        const widget = chatWidgetService.getWidgetBySessionResource(requestModel.session.sessionResource);
         const modeInfo = widget?.input.currentModeInfo;
         let agentReady = false;
         let languageModelReady = false;
         let toolsModelReady = false;
         const whenAgentReady = this.whenAgentReady(chatAgentService, modeInfo?.kind)?.then(() => agentReady = true);
-        const whenLanguageModelReady = this.whenLanguageModelReady(languageModelsService)?.then(() => languageModelReady = true);
+        const whenLanguageModelReady = this.whenLanguageModelReady(languageModelsService, requestModel.modelId)?.then(() => languageModelReady = true);
         const whenToolsModelReady = this.whenToolsModelReady(languageModelToolsService, requestModel)?.then(() => toolsModelReady = true);
         if (whenLanguageModelReady instanceof Promise || whenAgentReady instanceof Promise || whenToolsModelReady instanceof Promise) {
             const timeoutHandle = setTimeout(() => {
                 progress({
                     kind: 'progressMessage',
-                    content: ( new MarkdownString(( localize(5260, "Chat is almost ready...")))),
+                    content: ( new MarkdownString(( localize(5424, "Chat is almost ready...")))),
                 });
             }, 10000);
             try {
@@ -292,14 +297,14 @@ let SetupAgent = class SetupAgent extends Disposable {
                     if (ready === 'timedout') {
                         if (this.chatEntitlementService.anonymous) {
                             warningMessage = ( localize(
-                                5261,
+                                5425,
                                 "Chat took too long to get ready. Please ensure that the extension `{0}` is installed and enabled.",
                                 defaultChat.chatExtensionId
                             ));
                         }
                         else {
                             warningMessage = ( localize(
-                                5262,
+                                5426,
                                 "Chat took too long to get ready. Please ensure you are signed in to {0} and that the extension `{1}` is installed and enabled.",
                                 defaultChat.provider.default.name,
                                 defaultChat.chatExtensionId
@@ -309,14 +314,14 @@ let SetupAgent = class SetupAgent extends Disposable {
                     else {
                         if (this.chatEntitlementService.anonymous) {
                             warningMessage = ( localize(
-                                5263,
+                                5427,
                                 "Chat failed to get ready. Please ensure that the extension `{0}` is installed and enabled.",
                                 defaultChat.chatExtensionId
                             ));
                         }
                         else {
                             warningMessage = ( localize(
-                                5264,
+                                5428,
                                 "Chat failed to get ready. Please ensure you are signed in to {0} and that the extension `{1}` is installed and enabled.",
                                 defaultChat.provider.default.name,
                                 defaultChat.chatExtensionId
@@ -342,23 +347,27 @@ let SetupAgent = class SetupAgent extends Disposable {
         }
         await chatService.resendRequest(requestModel, {
             ...widget?.getModeRequestOptions(),
-            modeInfo
+            modeInfo,
+            userSelectedModelId: widget?.input.currentLanguageModel
         });
     }
-    whenLanguageModelReady(languageModelsService) {
-        const hasDefaultModel = () => {
+    whenLanguageModelReady(languageModelsService, modelId) {
+        const hasModelForRequest = () => {
+            if (modelId) {
+                return !!languageModelsService.lookupLanguageModel(modelId);
+            }
             for (const id of languageModelsService.getLanguageModelIds()) {
                 const model = languageModelsService.lookupLanguageModel(id);
-                if (model && model.isDefault) {
+                if (model?.isDefault) {
                     return true;
                 }
             }
             return false;
         };
-        if (hasDefaultModel()) {
+        if (hasModelForRequest()) {
             return;
         }
-        return Event.toPromise(Event.filter(languageModelsService.onDidChangeLanguageModels, () => hasDefaultModel() ?? false));
+        return Event.toPromise(Event.filter(languageModelsService.onDidChangeLanguageModels, () => hasModelForRequest()));
     }
     whenToolsModelReady(languageModelToolsService, requestModel) {
         const needsToolsModel = ( requestModel.message.parts.some(part => part instanceof ChatRequestToolPart));
@@ -404,7 +413,7 @@ let SetupAgent = class SetupAgent extends Disposable {
                     progress({
                         kind: 'progressMessage',
                         content: ( new MarkdownString(( localize(
-                            5265,
+                            5429,
                             "Signing in to {0}...",
                             ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id ? defaultChat.provider.enterprise.name : defaultChat.provider.default.name
                         )))),
@@ -413,7 +422,7 @@ let SetupAgent = class SetupAgent extends Disposable {
                 case ChatSetupStep.Installing:
                     progress({
                         kind: 'progressMessage',
-                        content: ( new MarkdownString(( localize(5266, "Getting chat ready...")))),
+                        content: ( new MarkdownString(( localize(5430, "Getting chat ready...")))),
                     });
                     break;
             }
@@ -439,13 +448,13 @@ let SetupAgent = class SetupAgent extends Disposable {
                 else if (requestModel) {
                     let newRequest = this.replaceAgentInRequestModel(requestModel, chatAgentService);
                     newRequest = this.replaceToolInRequestModel(newRequest);
-                    await this.forwardRequestToCopilot(newRequest, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+                    await this.forwardRequestToChat(newRequest, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
                 }
             }
             else {
                 progress({
                     kind: 'warning',
-                    content: ( new MarkdownString(( localize(5267, "Chat setup failed."))))
+                    content: ( new MarkdownString(( localize(5431, "Chat setup failed."))))
                 });
             }
         }
@@ -544,14 +553,14 @@ SetupAgent = SetupAgent_1 = ( __decorate([
     ( __param(8, IWorkspaceTrustManagementService)),
     ( __param(9, IChatEntitlementService))
 ], SetupAgent));
-class SetupTool extends Disposable {
+class SetupTool {
     static registerTool(instantiationService, toolData) {
         return instantiationService.invokeFunction(accessor => {
             const toolService = accessor.get(ILanguageModelToolsService);
             const disposables = ( new DisposableStore());
             const tool = instantiationService.createInstance(SetupTool);
             disposables.add(toolService.registerTool(toolData, tool));
-            return { tool, disposable: disposables };
+            return disposables;
         });
     }
     async invoke(invocation, countTokens, progress, token) {
@@ -569,6 +578,35 @@ class SetupTool extends Disposable {
         return undefined;
     }
 }
+let DefaultNewSymbolNamesProvider = DefaultNewSymbolNamesProvider_1 = class DefaultNewSymbolNamesProvider {
+    static registerProvider(instantiationService, context, controller) {
+        return instantiationService.invokeFunction(accessor => {
+            const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+            const disposables = ( new DisposableStore());
+            const provider = instantiationService.createInstance(DefaultNewSymbolNamesProvider_1, context, controller);
+            disposables.add(languageFeaturesService.newSymbolNamesProvider.register('*', provider));
+            return disposables;
+        });
+    }
+    constructor(context, controller, instantiationService, chatEntitlementService) {
+        this.context = context;
+        this.controller = controller;
+        this.instantiationService = instantiationService;
+        this.chatEntitlementService = chatEntitlementService;
+    }
+    async provideNewSymbolNames(model, range, triggerKind, token) {
+        await this.instantiationService.invokeFunction(accessor => {
+            return ChatSetup.getInstance(this.instantiationService, this.context, this.controller).run({
+                forceAnonymous: this.chatEntitlementService.anonymous ? ChatSetupAnonymous.EnabledWithDialog : undefined
+            });
+        });
+        return [];
+    }
+};
+DefaultNewSymbolNamesProvider = DefaultNewSymbolNamesProvider_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IChatEntitlementService))
+], DefaultNewSymbolNamesProvider));
 var ChatSetupStrategy;
 (function (ChatSetupStrategy) {
     ChatSetupStrategy[ChatSetupStrategy["Canceled"] = 0] = "Canceled";
@@ -588,7 +626,6 @@ let ChatSetup = class ChatSetup {
                 return ( new ChatSetup_1(
                     context,
                     controller,
-                    instantiationService,
                     accessor.get(ITelemetryService),
                     accessor.get(IWorkbenchLayoutService),
                     accessor.get(IKeybindingService),
@@ -596,16 +633,16 @@ let ChatSetup = class ChatSetup {
                     accessor.get(ILogService),
                     accessor.get(IConfigurationService),
                     accessor.get(IViewsService),
-                    accessor.get(IWorkspaceTrustRequestService)
+                    accessor.get(IWorkspaceTrustRequestService),
+                    accessor.get(IMarkdownRendererService)
                 ));
             });
         }
         return instance;
     }
-    constructor(context, controller, instantiationService, telemetryService, layoutService, keybindingService, chatEntitlementService, logService, configurationService, viewsService, workspaceTrustRequestService) {
+    constructor(context, controller, telemetryService, layoutService, keybindingService, chatEntitlementService, logService, configurationService, viewsService, workspaceTrustRequestService, markdownRendererService) {
         this.context = context;
         this.controller = controller;
-        this.instantiationService = instantiationService;
         this.telemetryService = telemetryService;
         this.layoutService = layoutService;
         this.keybindingService = keybindingService;
@@ -614,6 +651,7 @@ let ChatSetup = class ChatSetup {
         this.configurationService = configurationService;
         this.viewsService = viewsService;
         this.workspaceTrustRequestService = workspaceTrustRequestService;
+        this.markdownRendererService = markdownRendererService;
         this.pendingRun = undefined;
         this.skipDialogOnce = false;
     }
@@ -637,7 +675,7 @@ let ChatSetup = class ChatSetup {
         const dialogSkipped = this.skipDialogOnce;
         this.skipDialogOnce = false;
         const trusted = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localize(5268, "AI features are currently only supported in trusted workspaces."))
+            message: ( localize(5432, "AI features are currently only supported in trusted workspaces."))
         });
         if (!trusted) {
             this.context.update({ later: true });
@@ -658,7 +696,7 @@ let ChatSetup = class ChatSetup {
             setupStrategy = ChatSetupStrategy.SetupWithEnterpriseProvider;
         }
         if (setupStrategy !== ChatSetupStrategy.Canceled && !options?.disableChatViewReveal) {
-            showCopilotView(this.viewsService, this.layoutService);
+            showChatView(this.viewsService, this.layoutService);
         }
         let success = undefined;
         try {
@@ -692,8 +730,7 @@ let ChatSetup = class ChatSetup {
     }
     async showDialog(options) {
         const disposables = ( new DisposableStore());
-        const dialogVariant = this.configurationService.getValue('chat.setup.signInDialogVariant');
-        const buttons = this.getButtons(dialogVariant, options);
+        const buttons = this.getButtons(options);
         const dialog = disposables.add(( new Dialog(
             this.layoutService.activeContainer,
             this.getDialogTitle(options),
@@ -714,21 +751,21 @@ let ChatSetup = class ChatSetup {
         disposables.dispose();
         return buttons[button]?.[1] ?? ChatSetupStrategy.Canceled;
     }
-    getButtons(variant, options) {
+    getButtons(options) {
         const styleButton = (...classes) => ({ styleButton: (button) => button.element.classList.add(...classes) });
         let buttons;
         if (!options?.forceAnonymous && (this.context.state.entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog)) {
-            const defaultProviderButton = [( localize(5269, "Continue with {0}", defaultChat.provider.default.name)), ChatSetupStrategy.SetupWithoutEnterpriseProvider, styleButton('continue-button', 'default')];
+            const defaultProviderButton = [( localize(5433, "Continue with {0}", defaultChat.provider.default.name)), ChatSetupStrategy.SetupWithoutEnterpriseProvider, styleButton('continue-button', 'default')];
             const defaultProviderLink = [defaultProviderButton[0], defaultProviderButton[1], styleButton('link-button')];
-            const enterpriseProviderButton = [( localize(5269, "Continue with {0}", defaultChat.provider.enterprise.name)), ChatSetupStrategy.SetupWithEnterpriseProvider, styleButton('continue-button', 'default')];
+            const enterpriseProviderButton = [( localize(5433, "Continue with {0}", defaultChat.provider.enterprise.name)), ChatSetupStrategy.SetupWithEnterpriseProvider, styleButton('continue-button', 'default')];
             const enterpriseProviderLink = [enterpriseProviderButton[0], enterpriseProviderButton[1], styleButton('link-button')];
-            const googleProviderButton = [( localize(5269, "Continue with {0}", defaultChat.provider.google.name)), ChatSetupStrategy.SetupWithGoogleProvider, styleButton('continue-button', 'google')];
-            const appleProviderButton = [( localize(5269, "Continue with {0}", defaultChat.provider.apple.name)), ChatSetupStrategy.SetupWithAppleProvider, styleButton('continue-button', 'apple')];
+            const googleProviderButton = [( localize(5433, "Continue with {0}", defaultChat.provider.google.name)), ChatSetupStrategy.SetupWithGoogleProvider, styleButton('continue-button', 'google')];
+            const appleProviderButton = [( localize(5433, "Continue with {0}", defaultChat.provider.apple.name)), ChatSetupStrategy.SetupWithAppleProvider, styleButton('continue-button', 'apple')];
             if (ChatEntitlementRequests.providerId(this.configurationService) !== defaultChat.provider.enterprise.id) {
                 buttons = coalesce([
                     defaultProviderButton,
                     googleProviderButton,
-                    variant === 'apple' ? appleProviderButton : undefined,
+                    appleProviderButton,
                     enterpriseProviderLink
                 ]);
             }
@@ -736,38 +773,37 @@ let ChatSetup = class ChatSetup {
                 buttons = coalesce([
                     enterpriseProviderButton,
                     googleProviderButton,
-                    variant === 'apple' ? appleProviderButton : undefined,
+                    appleProviderButton,
                     defaultProviderLink
                 ]);
             }
         }
         else {
-            buttons = [[( localize(5270, "Set up Copilot")), ChatSetupStrategy.DefaultSetup, undefined]];
+            buttons = [[( localize(5434, "Use AI Features")), ChatSetupStrategy.DefaultSetup, undefined]];
         }
-        buttons.push([( localize(5271, "Skip for now")), ChatSetupStrategy.Canceled, styleButton('link-button', 'skip-button')]);
+        buttons.push([( localize(5435, "Skip for now")), ChatSetupStrategy.Canceled, styleButton('link-button', 'skip-button')]);
         return buttons;
     }
     getDialogTitle(options) {
         if (this.chatEntitlementService.anonymous) {
             if (options?.forceAnonymous) {
-                return localize(5272, "Start using GitHub Copilot");
+                return localize(5436, "Start using AI Features");
             }
             else {
-                return localize(5273, "Enable more AI features");
+                return localize(5437, "Enable more AI features");
             }
         }
         if (this.context.state.entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog) {
-            return localize(5274, "Sign in to use GitHub Copilot");
+            return localize(5438, "Sign in to use AI Features");
         }
-        return localize(5272, "Start using GitHub Copilot");
+        return localize(5436, "Start using AI Features");
     }
     createDialogFooter(disposables, options) {
         const element = $('.chat-setup-dialog-footer');
-        const markdown = this.instantiationService.createInstance(MarkdownRenderer, {});
         let footer;
         if (options?.forceAnonymous || this.telemetryService.telemetryLevel === TelemetryLevel.NONE) {
             footer = ( localize(
-                5275,
+                5439,
                 "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}).",
                 defaultChat.provider.default.name,
                 defaultChat.termsStatementUrl,
@@ -776,7 +812,7 @@ let ChatSetup = class ChatSetup {
         }
         else {
             footer = ( localize(
-                5276,
+                5440,
                 "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}). {3} Copilot may show [public code]({4}) suggestions and use your data to improve the product. You can change these [settings]({5}) anytime.",
                 defaultChat.provider.default.name,
                 defaultChat.termsStatementUrl,
@@ -786,29 +822,30 @@ let ChatSetup = class ChatSetup {
                 defaultChat.manageSettingsUrl
             ));
         }
-        element.appendChild($('p', undefined, disposables.add(markdown.render(( new MarkdownString(footer, { isTrusted: true })))).element));
+        element.appendChild($('p', undefined, disposables.add(this.markdownRendererService.render(( new MarkdownString(footer, { isTrusted: true })))).element));
         return element;
     }
 };
 ChatSetup = ChatSetup_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ITelemetryService)),
-    ( __param(4, ILayoutService)),
-    ( __param(5, IKeybindingService)),
-    ( __param(6, IChatEntitlementService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, IViewsService)),
-    ( __param(10, IWorkspaceTrustRequestService))
+    ( __param(2, ITelemetryService)),
+    ( __param(3, ILayoutService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IChatEntitlementService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IViewsService)),
+    ( __param(9, IWorkspaceTrustRequestService)),
+    ( __param(10, IMarkdownRendererService))
 ], ChatSetup));
 let ChatSetupContribution = class ChatSetupContribution extends Disposable {
     static { this.ID = 'workbench.contrib.chatSetup'; }
-    constructor(productService, instantiationService, commandService, telemetryService, chatEntitlementService, logService, contextKeyService, extensionEnablementService, extensionsWorkbenchService, extensionService, environmentService, configurationService) {
+    constructor(productService, instantiationService, commandService, telemetryService, chatEntitlementService, chatModeService, logService, contextKeyService, extensionEnablementService, extensionsWorkbenchService, extensionService, environmentService, configurationService) {
         super();
         this.productService = productService;
         this.instantiationService = instantiationService;
         this.commandService = commandService;
         this.telemetryService = telemetryService;
+        this.chatModeService = chatModeService;
         this.logService = logService;
         this.contextKeyService = contextKeyService;
         this.extensionEnablementService = extensionEnablementService;
@@ -835,44 +872,57 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
         }
         const defaultAgentDisposables = markAsSingleton(( new MutableDisposable()));
         const vscodeAgentDisposables = markAsSingleton(( new MutableDisposable()));
+        const renameProviderDisposables = markAsSingleton(( new MutableDisposable()));
         const updateRegistration = () => {
-            if (!context.state.hidden && !context.state.disabled) {
-                if (!defaultAgentDisposables.value) {
-                    const disposables = defaultAgentDisposables.value = ( new DisposableStore());
-                    const panelAgentDisposables = disposables.add(( new DisposableStore()));
-                    for (const mode of [ChatModeKind.Ask, ChatModeKind.Edit, ChatModeKind.Agent]) {
-                        const { agent, disposable } = SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Chat, mode, context, controller);
-                        panelAgentDisposables.add(disposable);
-                        panelAgentDisposables.add(agent.onUnresolvableError(() => {
-                            const panelAgentHasGuidance = ( chatViewsWelcomeRegistry.get().some(descriptor => this.contextKeyService.contextMatchesRules(descriptor.when)));
-                            if (panelAgentHasGuidance) {
-                                this.logService.error('[chat setup] Unresolvable error from Copilot agent registration, clearing registration.');
-                                panelAgentDisposables.dispose();
-                            }
-                        }));
+            {
+                if (!context.state.hidden && !context.state.disabled) {
+                    if (!defaultAgentDisposables.value) {
+                        const disposables = defaultAgentDisposables.value = ( new DisposableStore());
+                        const panelAgentDisposables = disposables.add(( new DisposableStore()));
+                        for (const mode of [ChatModeKind.Ask, ChatModeKind.Edit, ChatModeKind.Agent]) {
+                            const { agent, disposable } = SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Chat, mode, context, controller);
+                            panelAgentDisposables.add(disposable);
+                            panelAgentDisposables.add(agent.onUnresolvableError(() => {
+                                const panelAgentHasGuidance = ( chatViewsWelcomeRegistry.get().some(descriptor => this.contextKeyService.contextMatchesRules(descriptor.when)));
+                                if (panelAgentHasGuidance) {
+                                    this.logService.error('[chat setup] Unresolvable error from Chat agent registration, clearing registration.');
+                                    panelAgentDisposables.dispose();
+                                }
+                            }));
+                        }
+                        disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Terminal, undefined, context, controller).disposable);
+                        disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Notebook, undefined, context, controller).disposable);
+                        disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.EditorInline, undefined, context, controller).disposable);
+                    }
+                    if ((!context.state.installed || context.state.entitlement === ChatEntitlement.Unknown || context.state.entitlement === ChatEntitlement.Unresolved) && !vscodeAgentDisposables.value) {
+                        const disposables = vscodeAgentDisposables.value = ( new DisposableStore());
+                        disposables.add(SetupAgent.registerBuiltInAgents(this.instantiationService, context, controller));
                     }
-                    disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Terminal, undefined, context, controller).disposable);
-                    disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Notebook, undefined, context, controller).disposable);
-                    disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.EditorInline, undefined, context, controller).disposable);
                 }
-                if ((!context.state.installed || context.state.entitlement === ChatEntitlement.Unknown || context.state.entitlement === ChatEntitlement.Unresolved) && !vscodeAgentDisposables.value) {
-                    const disposables = vscodeAgentDisposables.value = ( new DisposableStore());
-                    disposables.add(SetupAgent.registerBuiltInAgents(this.instantiationService, context, controller).disposable);
+                else {
+                    defaultAgentDisposables.clear();
+                    vscodeAgentDisposables.clear();
+                }
+                if (context.state.installed && !context.state.disabled) {
+                    vscodeAgentDisposables.clear();
                 }
             }
-            else {
-                defaultAgentDisposables.clear();
-                vscodeAgentDisposables.clear();
-            }
-            if (context.state.installed && !context.state.disabled) {
-                vscodeAgentDisposables.clear();
+            {
+                if (!context.state.installed && !context.state.hidden && !context.state.disabled) {
+                    if (!renameProviderDisposables.value) {
+                        renameProviderDisposables.value = DefaultNewSymbolNamesProvider.registerProvider(this.instantiationService, context, controller);
+                    }
+                }
+                else {
+                    renameProviderDisposables.clear();
+                }
             }
         };
         this._register(Event.runAndSubscribe(context.onDidChange, () => updateRegistration()));
     }
     registerActions(context, requests, controller) {
         class ChatSetupTriggerAction extends Action2 {
-            static { this.CHAT_SETUP_ACTION_LABEL = ( localize2(5277, "Use AI Features with Copilot for free...")); }
+            static { this.CHAT_SETUP_ACTION_LABEL = ( localize2(5441, "Use AI Features with Copilot for free...")); }
             constructor() {
                 super({
                     id: CHAT_SETUP_ACTION_ID,
@@ -899,7 +949,7 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
                 await context.update({ hidden: false });
                 configurationService.updateValue(ChatTeardownContribution.CHAT_DISABLED_CONFIGURATION_KEY, false);
                 if (mode) {
-                    const chatWidget = await showCopilotView(viewsService, layoutService);
+                    const chatWidget = await showChatView(viewsService, layoutService);
                     chatWidget?.input.setChatMode(mode);
                 }
                 const setup = ChatSetup.getInstance(instantiationService, context, controller);
@@ -907,8 +957,8 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
                 if (success === false && !lifecycleService.willShutdown) {
                     const { confirmed } = await dialogService.confirm({
                         type: Severity.Error,
-                        message: ( localize(5278, "Chat setup failed. Would you like to try again?")),
-                        primaryButton: ( localize(5279, "Retry")),
+                        message: ( localize(5442, "Chat setup failed. Would you like to try again?")),
+                        primaryButton: ( localize(5443, "Retry")),
                     });
                     if (confirmed) {
                         return Boolean(await commandService.executeCommand(CHAT_SETUP_ACTION_ID, mode, options));
@@ -938,7 +988,7 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
             constructor() {
                 super({
                     id: 'workbench.action.chat.triggerSetupForceSignIn',
-                    title: ( localize2(5280, "Sign in to use AI features"))
+                    title: ( localize2(5444, "Sign in to use AI features"))
                 });
             }
             async run(accessor) {
@@ -966,7 +1016,7 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
             constructor() {
                 super({
                     id: 'workbench.action.chat.triggerSetupFromAccounts',
-                    title: ( localize2(5281, "Sign in to use AI features...")),
+                    title: ( localize2(5445, "Sign in to use AI features...")),
                     menu: {
                         id: MenuId.AccountsContext,
                         group: '2_copilot',
@@ -986,8 +1036,8 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
             constructor() {
                 super({
                     id: 'workbench.action.chat.upgradePlan',
-                    title: ( localize2(5282, "Upgrade to GitHub Copilot Pro")),
-                    category: ( localize2(5283, 'Chat')),
+                    title: ( localize2(5446, "Upgrade to GitHub Copilot Pro")),
+                    category: ( localize2(5447, 'Chat')),
                     f1: true,
                     precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ContextKeyExpr.or(
                         ChatContextKeys.Entitlement.canSignUp,
@@ -1028,8 +1078,8 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
             constructor() {
                 super({
                     id: 'workbench.action.chat.manageOverages',
-                    title: ( localize2(5284, "Manage GitHub Copilot Overages")),
-                    category: ( localize2(5283, 'Chat')),
+                    title: ( localize2(5448, "Manage GitHub Copilot Overages")),
+                    category: ( localize2(5447, 'Chat')),
                     f1: true,
                     precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ContextKeyExpr.or(
                         ChatContextKeys.Entitlement.planPro,
@@ -1070,8 +1120,19 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
             handleURL: async (url) => {
                 const params = ( new URLSearchParams(url.query));
                 this.telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'url', detail: params.get('referrer') ?? undefined });
-                await this.commandService.executeCommand(CHAT_SETUP_ACTION_ID, validateChatMode(params.get('mode')));
-                return true;
+                const agentParam = params.get('agent') ?? params.get('mode');
+                if (agentParam) {
+                    const agents = this.chatModeService.getModes();
+                    const allAgents = [...agents.builtin, ...agents.custom];
+                    let foundAgent = allAgents.find(agent => agent.id === agentParam);
+                    if (!foundAgent) {
+                        const nameLower = agentParam.toLowerCase();
+                        foundAgent = allAgents.find(agent => agent.name.get().toLowerCase() === nameLower);
+                    }
+                    await this.commandService.executeCommand(CHAT_SETUP_ACTION_ID, foundAgent?.id);
+                    return true;
+                }
+                return false;
             }
         }));
     }
@@ -1115,13 +1176,14 @@ ChatSetupContribution = ( __decorate([
     ( __param(2, ICommandService)),
     ( __param(3, ITelemetryService)),
     ( __param(4, IChatEntitlementService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IContextKeyService)),
-    ( __param(7, IWorkbenchExtensionEnablementService)),
-    ( __param(8, IExtensionsWorkbenchService)),
-    ( __param(9, IExtensionService)),
-    ( __param(10, IEnvironmentService)),
-    ( __param(11, IConfigurationService))
+    ( __param(5, IChatModeService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IWorkbenchExtensionEnablementService)),
+    ( __param(9, IExtensionsWorkbenchService)),
+    ( __param(10, IExtensionService)),
+    ( __param(11, IEnvironmentService)),
+    ( __param(12, IConfigurationService))
 ], ChatSetupContribution));
 let ChatTeardownContribution = class ChatTeardownContribution extends Disposable {
     static { ChatTeardownContribution_1 = this; }
@@ -1178,7 +1240,7 @@ let ChatTeardownContribution = class ChatTeardownContribution extends Disposable
             return;
         }
         await this.extensionsWorkbenchService.setEnablement([defaultChatExtension], state);
-        await this.extensionsWorkbenchService.updateRunningExtensions(state === EnablementState.EnabledGlobally || state === EnablementState.EnabledWorkspace ? ( localize(5285, "Enabling AI features")) : ( localize(5286, "Disabling AI features")));
+        await this.extensionsWorkbenchService.updateRunningExtensions(state === EnablementState.EnabledGlobally || state === EnablementState.EnabledWorkspace ? ( localize(5449, "Enabling AI features")) : ( localize(5450, "Disabling AI features")));
     }
     maybeHideAuxiliaryBar() {
         const activeContainers = this.viewDescriptorService.getViewContainersByLocation(ViewContainerLocation.AuxiliaryBar).filter(container => this.viewDescriptorService.getViewContainerModel(container).activeViewDescriptors.length > 0);
@@ -1191,14 +1253,14 @@ let ChatTeardownContribution = class ChatTeardownContribution extends Disposable
     registerActions() {
         class ChatSetupHideAction extends Action2 {
             static { this.ID = 'workbench.action.chat.hideSetup'; }
-            static { this.TITLE = ( localize2(5287, "Learn How to Hide AI Features")); }
+            static { this.TITLE = ( localize2(5451, "Learn How to Hide AI Features")); }
             constructor() {
                 super({
                     id: ChatSetupHideAction.ID,
                     title: ChatSetupHideAction.TITLE,
                     f1: true,
                     category: CHAT_CATEGORY,
-                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.installed.negate()))),
+                    precondition: ( ChatContextKeys.Setup.hidden.negate()),
                     menu: {
                         id: MenuId.ChatTitleBarMenu,
                         group: 'z_hide',
@@ -1264,7 +1326,7 @@ let ChatSetupController = class ChatSetupController extends Disposable {
     }
     async setup(options = {}) {
         const watch = ( new StopWatch(false));
-        const title = ( localize(5288, "Getting chat ready..."));
+        const title = ( localize(5452, "Getting chat ready..."));
         const badge = this.activityService.showViewContainerActivity(CHAT_SIDEBAR_PANEL_ID, {
             badge: ( new ProgressBadge(() => title)),
         });
@@ -1335,12 +1397,12 @@ let ChatSetupController = class ChatSetupController extends Disposable {
             const { confirmed } = await this.dialogService.confirm({
                 type: Severity.Error,
                 message: ( localize(
-                    5289,
+                    5453,
                     "Failed to sign in to {0}. Would you like to try again?",
                     ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id ? defaultChat.provider.enterprise.name : defaultChat.provider.default.name
                 )),
-                detail: ( localize(5290, "You must be signed in to use AI features.")),
-                primaryButton: ( localize(5279, "Retry"))
+                detail: ( localize(5454, "You must be signed in to use AI features.")),
+                primaryButton: ( localize(5443, "Retry"))
             });
             if (confirmed) {
                 return this.signIn(options);
@@ -1411,11 +1473,11 @@ let ChatSetupController = class ChatSetupController extends Disposable {
                 const { confirmed } = await this.dialogService.confirm({
                     type: Severity.Error,
                     message: ( localize(
-                        5291,
+                        5455,
                         "An error occurred while setting up chat. Would you like to try again?"
                     )),
                     detail: error && !isCancellationError(error) ? toErrorMessage(error) : undefined,
-                    primaryButton: ( localize(5279, "Retry"))
+                    primaryButton: ( localize(5443, "Retry"))
                 });
                 if (confirmed) {
                     return this.doInstallWithRetry();
@@ -1486,8 +1548,8 @@ let ChatSetupController = class ChatSetupController extends Disposable {
         }
         let isSingleWord = false;
         const result = await this.quickInputService.input({
-            prompt: ( localize(5292, "What is your {0} instance?", defaultChat.provider.enterprise.name)),
-            placeHolder: ( localize(5293, 'i.e. "octocat" or "https://octocat.ghe.com"...')),
+            prompt: ( localize(5456, "What is your {0} instance?", defaultChat.provider.enterprise.name)),
+            placeHolder: ( localize(5457, 'i.e. "octocat" or "https://octocat.ghe.com"...')),
             ignoreFocusLost: true,
             value: uri,
             validateInput: async (value) => {
@@ -1498,14 +1560,14 @@ let ChatSetupController = class ChatSetupController extends Disposable {
                 if (domainRegEx.test(value)) {
                     isSingleWord = true;
                     return {
-                        content: ( localize(5294, "Will resolve to {0}", `https://${value}.ghe.com`)),
+                        content: ( localize(5458, "Will resolve to {0}", `https://${value}.ghe.com`)),
                         severity: Severity.Info
                     };
                 }
                 if (!fullUriRegEx.test(value)) {
                     return {
                         content: ( localize(
-                            5295,
+                            5459,
                             'You must enter a valid {0} instance (i.e. "octocat" or "https://octocat.ghe.com")',
                             defaultChat.provider.enterprise.name
                         )),