@codingame/monaco-vscode-chat-service-override 13.1.6 → 14.0.0

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

@@ -2,14 +2,14 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import './media/chatViewSetup.css.js';
 import { getActiveElement, $, setVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { Button, ButtonWithDropdown } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { ButtonWithDropdown } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
 import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
 import { toAction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
 import { timeout, Barrier } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
 import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
@@ -17,6 +17,7 @@ import { MarkdownRenderer } from '@codingame/monaco-vscode-api/vscode/vs/editor/
 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';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
@@ -42,17 +43,16 @@ import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/wo
 import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
 import { ProgressBadge } from '@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-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 { IAuthenticationService, IAuthenticationExtensionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
 import { IWorkbenchExtensionEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
-import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { Parts } from '@codingame/monaco-vscode-e7080bda-ce3e-5243-9a35-98cd9634dbda-common/vscode/vs/workbench/services/layout/browser/layoutService';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
 import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
 import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { CHAT_CATEGORY } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { ensureSideBarChatViewSize, ChatViewId, EditsViewId, showEditsView, showChatView } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { showCopilotView, ensureSideBarChatViewSize, ChatViewId, preferCopilotEditsView, EditsViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
 import { CHAT_EDITING_SIDEBAR_PANEL_ID, CHAT_SIDEBAR_PANEL_ID } from './chatViewPane.js';
 import { ChatViewsWelcomeExtensions } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
 import { IChatQuotasService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatQuotasService.service';
@@ -61,18 +61,34 @@ import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { ExtensionUrlHandlerOverrideRegistry } from '@codingame/monaco-vscode-8c844347-a703-5de1-9eeb-5e0c7f503a58-common/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
+import { IWorkspaceTrustRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { equalsIgnoreCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
 
-var ChatSetupContext_1;
+var ChatSetupRequests_1, ChatSetupContext_1;
 const defaultChat = {
     extensionId: product.defaultChatAgent?.extensionId ?? '',
+    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
     documentationUrl: product.defaultChatAgent?.documentationUrl ?? '',
     termsStatementUrl: product.defaultChatAgent?.termsStatementUrl ?? '',
     privacyStatementUrl: product.defaultChatAgent?.privacyStatementUrl ?? '',
     skusDocumentationUrl: product.defaultChatAgent?.skusDocumentationUrl ?? '',
     publicCodeMatchesUrl: product.defaultChatAgent?.publicCodeMatchesUrl ?? '',
     upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',
-    providerIds: [product.defaultChatAgent?.providerId ?? '', 'github-enterprise'],
+    providerId: product.defaultChatAgent?.providerId ?? '',
     providerName: product.defaultChatAgent?.providerName ?? '',
+    enterpriseProviderId: product.defaultChatAgent?.enterpriseProviderId ?? '',
+    enterpriseProviderName: product.defaultChatAgent?.enterpriseProviderName ?? '',
+    providerSetting: product.defaultChatAgent?.providerSetting ?? '',
+    providerUriSetting: product.defaultChatAgent?.providerUriSetting ?? '',
     providerScopes: product.defaultChatAgent?.providerScopes ?? [[]],
     entitlementUrl: product.defaultChatAgent?.entitlementUrl ?? '',
     entitlementSignupLimitedUrl: product.defaultChatAgent?.entitlementSignupLimitedUrl ?? '',
@@ -88,38 +104,42 @@ var ChatEntitlement;
     ChatEntitlement[ChatEntitlement["Pro"] = 6] = "Pro";
 })(ChatEntitlement || (ChatEntitlement = {}));
 const TRIGGER_SETUP_COMMAND_ID = 'workbench.action.chat.triggerSetup';
-const TRIGGER_SETUP_COMMAND_LABEL = ( localize2(4538, "Use AI Features with Copilot for Free..."));
-const SetupWelcomeViewKeys = ( new Set(
-    [ChatContextKeys.Setup.triggered.key, ChatContextKeys.Setup.installed.key, ChatContextKeys.Setup.signedOut.key, ChatContextKeys.Setup.canSignUp.key]
-));
-const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('config.chat.experimental.offerSetup')), ( ContextKeyExpr.or(( ContextKeyExpr.and(ChatContextKeys.Setup.triggered, ( ChatContextKeys.Setup.installed.negate()))), ( ContextKeyExpr.and(ChatContextKeys.Setup.canSignUp, ChatContextKeys.Setup.installed)), ( ContextKeyExpr.and(ChatContextKeys.Setup.signedOut, ChatContextKeys.Setup.installed))))));
-(class ChatSetupContribution extends Disposable {
+const TRIGGER_SETUP_COMMAND_LABEL = ( localize2(4635, "Use AI Features with Copilot for Free..."));
+let ChatSetupContribution = class ChatSetupContribution extends Disposable {
     static { this.ID = 'workbench.chat.setup'; }
-    constructor(productService, instantiationService) {
+    constructor(productService, instantiationService, environmentService, commandService, telemetryService, experimentService) {
         super();
         this.productService = productService;
         this.instantiationService = instantiationService;
-        this.context = this._register(this.instantiationService.createInstance(ChatSetupContext));
-        this.requests = this._register(this.instantiationService.createInstance(ChatSetupRequests, this.context));
-        this.controller = ( new Lazy(
-            () => this._register(this.instantiationService.createInstance(ChatSetupController, this.context, this.requests))
-        ));
-        if (!this.productService.defaultChatAgent) {
+        this.environmentService = environmentService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.experimentService = experimentService;
+        if (!this.productService.defaultChatAgent ||
+            (isWeb && !this.environmentService.remoteAuthority)
+        ) {
             return;
         }
-        this.registerChatWelcome();
-        this.registerActions();
+        const context = this._register(this.instantiationService.createInstance(ChatSetupContext));
+        const requests = this._register(this.instantiationService.createInstance(ChatSetupRequests, context));
+        const controller = ( new Lazy(
+            () => this._register(this.instantiationService.createInstance(ChatSetupController, context, requests))
+        ));
+        this.registerChatWelcome(controller, context);
+        this.registerActions(context, requests);
+        this.registerUrlLinkHandler();
+        this.registerSetting(context);
     }
-    registerChatWelcome() {
+    registerChatWelcome(controller, context) {
         ( Registry.as(ChatViewsWelcomeExtensions.ChatViewsWelcomeRegistry)).register({
-            title: ( localize(4539, "Welcome to Copilot")),
-            when: SetupWelcomeViewCondition,
+            title: ( localize(4636, "Welcome to Copilot")),
+            when: ChatContextKeys.SetupViewCondition,
             icon: Codicon.copilotLarge,
-            content: disposables => disposables.add(this.instantiationService.createInstance(ChatSetupWelcomeContent, this.controller.value, this.context)).element,
+            content: disposables => disposables.add(this.instantiationService.createInstance(ChatSetupWelcomeContent, controller.value, context)).element,
         });
     }
-    registerActions() {
-        const that = this;
+    registerActions(context, requests) {
+        const chatSetupTriggerContext = ( ContextKeyExpr.or(( ChatContextKeys.Setup.installed.negate()), ChatContextKeys.Setup.canSignUp));
         class ChatSetupTriggerAction extends Action2 {
             constructor() {
                 super({
@@ -127,40 +147,36 @@ const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('con
                     title: TRIGGER_SETUP_COMMAND_LABEL,
                     category: CHAT_CATEGORY,
                     f1: true,
-                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.installed.negate()), ( ContextKeyExpr.has('config.chat.experimental.offerSetup')))),
+                    precondition: chatSetupTriggerContext,
                     menu: {
                         id: MenuId.ChatCommandCenter,
                         group: 'a_last',
                         order: 1,
-                        when: ( ChatContextKeys.Setup.installed.negate())
+                        when: chatSetupTriggerContext
                     }
                 });
             }
-            async run(accessor, startSetup) {
+            async run(accessor) {
                 const viewsService = accessor.get(IViewsService);
                 const viewDescriptorService = accessor.get(IViewDescriptorService);
                 const configurationService = accessor.get(IConfigurationService);
                 const layoutService = accessor.get(IWorkbenchLayoutService);
-                await that.context.update({ triggered: true });
+                await context.update({ hidden: false });
                 showCopilotView(viewsService, layoutService);
-                ensureSideBarChatViewSize(400, viewDescriptorService, layoutService);
-                if (startSetup === true) {
-                    const controller = that.controller.value;
-                    controller.setup();
-                }
+                ensureSideBarChatViewSize(viewDescriptorService, layoutService, viewsService);
                 configurationService.updateValue('chat.commandCenter.enabled', true);
             }
         }
         class ChatSetupHideAction extends Action2 {
             static { this.ID = 'workbench.action.chat.hideSetup'; }
-            static { this.TITLE = ( localize2(4540, "Hide Copilot")); }
+            static { this.TITLE = ( localize2(4637, "Hide Copilot")); }
             constructor() {
                 super({
                     id: ChatSetupHideAction.ID,
                     title: ChatSetupHideAction.TITLE,
                     f1: true,
                     category: CHAT_CATEGORY,
-                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.installed.negate()), ( ContextKeyExpr.has('config.chat.experimental.offerSetup')))),
+                    precondition: ( ChatContextKeys.Setup.installed.negate()),
                     menu: {
                         id: MenuId.ChatCommandCenter,
                         group: 'z_hide',
@@ -175,13 +191,13 @@ const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('con
                 const configurationService = accessor.get(IConfigurationService);
                 const dialogService = accessor.get(IDialogService);
                 const { confirmed } = await dialogService.confirm({
-                    message: ( localize(4541, "Are you sure you want to hide Copilot?")),
+                    message: ( localize(4638, "Are you sure you want to hide Copilot?")),
                     detail: ( localize(
-                        4542,
+                        4639,
                         "You can restore Copilot by running the '{0}' command.",
                         TRIGGER_SETUP_COMMAND_LABEL.value
                     )),
-                    primaryButton: ( localize(4543, "Hide Copilot"))
+                    primaryButton: ( localize(4640, "Hide Copilot"))
                 });
                 if (!confirmed) {
                     return;
@@ -195,18 +211,18 @@ const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('con
             constructor() {
                 super({
                     id: 'workbench.action.chat.upgradePlan',
-                    title: ( localize2(4544, "Upgrade to Copilot Pro")),
-                    category: ( localize2(4545, 'Chat')),
+                    title: ( localize2(4641, "Upgrade to Copilot Pro")),
+                    category: ( localize2(4642, 'Chat')),
                     f1: true,
-                    precondition: ChatContextKeys.enabled,
+                    precondition: ( ContextKeyExpr.or(ChatContextKeys.Setup.canSignUp, ChatContextKeys.Setup.limited)),
                     menu: {
                         id: MenuId.ChatCommandCenter,
                         group: 'a_first',
                         order: 1,
-                        when: ( ContextKeyExpr.and(ChatContextKeys.Setup.installed, ( ContextKeyExpr.or(
+                        when: ( ContextKeyExpr.or(
                             ChatContextKeys.chatQuotaExceeded,
                             ChatContextKeys.completionsQuotaExceeded
-                        ))))
+                        ))
                     }
                 });
             }
@@ -217,7 +233,7 @@ const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('con
                 const commandService = accessor.get(ICommandService);
                 telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: 'chat' });
                 openerService.open(( URI.parse(defaultChat.upgradePlanUrl)));
-                const entitlement = that.context.state.entitlement;
+                const entitlement = context.state.entitlement;
                 if (entitlement !== ChatEntitlement.Pro) {
                     windowFocusListener.value = hostService.onDidChangeFocus(focus => this.onWindowFocus(focus, commandService));
                 }
@@ -225,16 +241,16 @@ const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('con
             async onWindowFocus(focus, commandService) {
                 if (focus) {
                     windowFocusListener.clear();
-                    const entitlement = await that.requests.forceResolveEntitlement(undefined);
+                    const entitlement = await requests.forceResolveEntitlement(undefined);
                     if (entitlement === ChatEntitlement.Pro) {
-                        commandService.executeCommand('github.copilot.refreshToken');
+                        refreshTokens(commandService);
                     }
                 }
             }
         }
         async function hideSetupView(viewsDescriptorService, layoutService) {
             const location = viewsDescriptorService.getViewLocationById(ChatViewId);
-            await that.context.update({ triggered: false });
+            await context.update({ hidden: true });
             if (location === ViewContainerLocation.AuxiliaryBar) {
                 const activeContainers = viewsDescriptorService.getViewContainersByLocation(location).filter(container => viewsDescriptorService.getViewContainerModel(container).activeViewDescriptors.length > 0);
                 if (activeContainers.length === 0) {
@@ -246,8 +262,66 @@ const SetupWelcomeViewCondition = ( ContextKeyExpr.and(( ContextKeyExpr.has('con
         registerAction2(ChatSetupHideAction);
         registerAction2(UpgradePlanAction);
     }
-});
-let ChatSetupRequests = class ChatSetupRequests extends Disposable {
+    registerUrlLinkHandler() {
+        this._register(ExtensionUrlHandlerOverrideRegistry.registerHandler({
+            canHandleURL: url => {
+                return url.scheme === this.productService.urlProtocol && equalsIgnoreCase(url.authority, defaultChat.chatExtensionId);
+            },
+            handleURL: async (url) => {
+                const params = ( new URLSearchParams(url.query));
+                this.telemetryService.publicLog2('workbenchActionExecuted', { id: TRIGGER_SETUP_COMMAND_ID, from: 'url', detail: params.get('referrer') ?? undefined });
+                await this.commandService.executeCommand(TRIGGER_SETUP_COMMAND_ID);
+                return true;
+            }
+        }));
+    }
+    registerSetting(context) {
+        const configurationRegistry = ( Registry.as(Extensions.Configuration));
+        let lastNode;
+        const registerSetting = () => {
+            const treatmentId = context.state.entitlement === ChatEntitlement.Limited ?
+                'chatAgentMaxRequestsFree' :
+                'chatAgentMaxRequestsPro';
+            this.experimentService.getTreatment(treatmentId).then(value => {
+                const defaultValue = value ?? (context.state.entitlement === ChatEntitlement.Limited ? 5 : 15);
+                const node = {
+                    id: 'chatSidebar',
+                    title: ( localize(4643, "Chat")),
+                    type: 'object',
+                    properties: {
+                        'chat.agent.maxRequests': {
+                            type: 'number',
+                            description: ( localize(
+                                4644,
+                                "The maximum number of requests to allow Copilot Edits to use in agent mode."
+                            )),
+                            default: defaultValue,
+                            tags: ['experimental']
+                        },
+                    }
+                };
+                configurationRegistry.updateConfigurations({ remove: lastNode ? [lastNode] : [], add: [node] });
+                lastNode = node;
+            });
+        };
+        this._register(Event.runAndSubscribe(Event.debounce(context.onDidChange, () => { }, 1000), () => registerSetting()));
+    }
+};
+ChatSetupContribution = ( __decorate([
+    ( __param(0, IProductService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IWorkbenchEnvironmentService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IWorkbenchAssignmentService))
+], ChatSetupContribution));
+let ChatSetupRequests = ChatSetupRequests_1 = class ChatSetupRequests extends Disposable {
+    static providerId(configurationService) {
+        if (configurationService.getValue(defaultChat.providerSetting) === defaultChat.enterpriseProviderId) {
+            return defaultChat.enterpriseProviderId;
+        }
+        return defaultChat.providerId;
+    }
     constructor(context, telemetryService, authenticationService, logService, requestService, chatQuotasService, dialogService, openerService, configurationService) {
         super();
         this.context = context;
@@ -268,17 +342,17 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
     registerListeners() {
         this._register(this.authenticationService.onDidChangeDeclaredProviders(() => this.resolve()));
         this._register(this.authenticationService.onDidChangeSessions(e => {
-            if (defaultChat.providerIds.includes(e.providerId)) {
+            if (e.providerId === ChatSetupRequests_1.providerId(this.configurationService)) {
                 this.resolve();
             }
         }));
         this._register(this.authenticationService.onDidRegisterAuthenticationProvider(e => {
-            if (defaultChat.providerIds.includes(e.id)) {
+            if (e.id === ChatSetupRequests_1.providerId(this.configurationService)) {
                 this.resolve();
             }
         }));
         this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(e => {
-            if (defaultChat.providerIds.includes(e.id)) {
+            if (e.id === ChatSetupRequests_1.providerId(this.configurationService)) {
                 this.resolve();
             }
         }));
@@ -314,21 +388,9 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
         }
     }
     async findMatchingProviderSession(token) {
-        let sessions = [];
-        const authProviderConfigValue = this.configurationService.getValue('github.copilot.advanced.authProvider');
-        if (authProviderConfigValue) {
-            sessions = await this.authenticationService.getSessions(authProviderConfigValue);
-        }
-        else {
-            for (const providerId of defaultChat.providerIds) {
-                if (token.isCancellationRequested) {
-                    return undefined;
-                }
-                sessions = await this.authenticationService.getSessions(providerId);
-                if (sessions.length) {
-                    break;
-                }
-            }
+        const sessions = await this.doGetSessions(ChatSetupRequests_1.providerId(this.configurationService));
+        if (token.isCancellationRequested) {
+            return undefined;
         }
         for (const session of sessions) {
             for (const scopes of defaultChat.providerScopes) {
@@ -339,6 +401,14 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
         }
         return undefined;
     }
+    async doGetSessions(providerId) {
+        try {
+            return await this.authenticationService.getSessions(providerId);
+        }
+        catch (error) {
+        }
+        return [];
+    }
     scopesMatch(scopes, expectedScopes) {
         return scopes.length === expectedScopes.length && expectedScopes.every(scope => scopes.includes(scope));
     }
@@ -351,6 +421,10 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
         return entitlements?.entitlement;
     }
     async doResolveEntitlement(session, token) {
+        if (ChatSetupRequests_1.providerId(this.configurationService) === defaultChat.enterpriseProviderId) {
+            this.logService.trace('[chat setup] entitlement: enterprise provider, assuming Pro');
+            return { entitlement: ChatEntitlement.Pro };
+        }
         if (token.isCancellationRequested) {
             return undefined;
         }
@@ -412,8 +486,10 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
         this.logService.trace(`[chat setup] entitlement: resolved to ${entitlements.entitlement}, quotas: ${JSON.stringify(entitlements.quotas)}`);
         this.telemetryService.publicLog2('chatInstallEntitlement', {
             entitlement: entitlements.entitlement,
+            tid: entitlementsResponse.analytics_tracking_id,
             quotaChat: entitlementsResponse.limited_user_quotas?.chat,
-            quotaCompletions: entitlementsResponse.limited_user_quotas?.completions
+            quotaCompletions: entitlementsResponse.limited_user_quotas?.completions,
+            quotaResetDate: entitlementsResponse.limited_user_reset_date
         });
         return entitlements;
     }
@@ -461,8 +537,8 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
         };
         const response = await this.request(defaultChat.entitlementSignupLimitedUrl, 'POST', body, session, CancellationToken.None);
         if (!response) {
-            this.onUnknownSignUpError('[chat setup] sign-up: no response');
-            return false;
+            const retry = await this.onUnknownSignUpError(( localize(4645, "No response received.")), '[chat setup] sign-up: no response');
+            return retry ? this.signUpLimited(session) : { errorCode: 1 };
         }
         if (response.res.statusCode && response.res.statusCode !== 200) {
             if (response.res.statusCode === 422) {
@@ -472,15 +548,15 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
                         const responseError = JSON.parse(responseText);
                         if (typeof responseError.message === 'string' && responseError.message) {
                             this.onUnprocessableSignUpError(`[chat setup] sign-up: unprocessable entity (${responseError.message})`, responseError.message);
-                            return false;
+                            return { errorCode: response.res.statusCode };
                         }
                     }
                 }
                 catch (error) {
                 }
             }
-            this.onUnknownSignUpError(`[chat setup] sign-up: unexpected status code ${response.res.statusCode}`);
-            return false;
+            const retry = await this.onUnknownSignUpError(( localize(4646, "Unexpected status code {0}.", response.res.statusCode)), `[chat setup] sign-up: unexpected status code ${response.res.statusCode}`);
+            return retry ? this.signUpLimited(session) : { errorCode: response.res.statusCode };
         }
         let responseText = null;
         try {
@@ -489,8 +565,8 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
         catch (error) {
         }
         if (!responseText) {
-            this.onUnknownSignUpError('[chat setup] sign-up: response has no content');
-            return false;
+            const retry = await this.onUnknownSignUpError(( localize(4647, "Response has no contents.")), '[chat setup] sign-up: response has no content');
+            return retry ? this.signUpLimited(session) : { errorCode: 2 };
         }
         let parsedResult = undefined;
         try {
@@ -498,48 +574,49 @@ let ChatSetupRequests = class ChatSetupRequests extends Disposable {
             this.logService.trace(`[chat setup] sign-up: response is ${responseText}`);
         }
         catch (err) {
-            this.onUnknownSignUpError(`[chat setup] sign-up: error parsing response (${err})`);
-        }
-        const subscribed = Boolean(parsedResult?.subscribed);
-        if (subscribed) {
-            this.logService.trace('[chat setup] sign-up: successfully subscribed');
-        }
-        else {
-            this.logService.error('[chat setup] sign-up: not subscribed');
-        }
-        if (subscribed) {
-            this.update({ entitlement: ChatEntitlement.Limited });
+            const retry = await this.onUnknownSignUpError(( localize(4648, "Invalid response contents.")), `[chat setup] sign-up: error parsing response (${err})`);
+            return retry ? this.signUpLimited(session) : { errorCode: 3 };
         }
-        return subscribed;
+        this.update({ entitlement: ChatEntitlement.Limited });
+        return Boolean(parsedResult?.subscribed);
     }
-    onUnknownSignUpError(logMessage) {
-        this.dialogService.error(( localize(4546, "An error occurred while signing up for Copilot Free.")), ( localize(4547, "Please try again.")));
+    async onUnknownSignUpError(detail, logMessage) {
         this.logService.error(logMessage);
+        const { confirmed } = await this.dialogService.confirm({
+            type: Severity.Error,
+            message: ( localize(
+                4649,
+                "An error occurred while signing up for Copilot Free. Would you like to try again?"
+            )),
+            detail,
+            primaryButton: ( localize(4650, "Retry"))
+        });
+        return confirmed;
     }
     onUnprocessableSignUpError(logMessage, logDetails) {
+        this.logService.error(logMessage);
         this.dialogService.prompt({
             type: Severity.Error,
-            message: ( localize(4548, "An error occurred while signing up for Copilot Free.")),
+            message: ( localize(4651, "An error occurred while signing up for Copilot Free.")),
             detail: logDetails,
             buttons: [
                 {
-                    label: ( localize(4549, "OK")),
+                    label: ( localize(4652, "OK")),
                     run: () => { }
                 },
                 {
-                    label: ( localize(4550, "Learn More")),
+                    label: ( localize(4653, "Learn More")),
                     run: () => this.openerService.open(( URI.parse(defaultChat.upgradePlanUrl)))
                 }
-            ],
+            ]
         });
-        this.logService.error(logMessage);
     }
     dispose() {
         this.pendingResolveCts.dispose(true);
         super.dispose();
     }
 };
-ChatSetupRequests = ( __decorate([
+ChatSetupRequests = ChatSetupRequests_1 = ( __decorate([
     ( __param(1, ITelemetryService)),
     ( __param(2, IAuthenticationService)),
     ( __param(3, ILogService)),
@@ -556,15 +633,14 @@ var ChatSetupStep;
     ChatSetupStep[ChatSetupStep["Installing"] = 3] = "Installing";
 })(ChatSetupStep || (ChatSetupStep = {}));
 let ChatSetupController = class ChatSetupController extends Disposable {
-    get step() {
-        return this._step;
-    }
-    constructor(context, requests, telemetryService, authenticationService, viewsService, extensionsWorkbenchService, productService, logService, progressService, chatAgentService, activityService, commandService, layoutService) {
+    get step() { return this._step; }
+    constructor(context, requests, telemetryService, authenticationService, authenticationExtensionsService, viewsService, extensionsWorkbenchService, productService, logService, progressService, chatAgentService, activityService, commandService, layoutService, workspaceTrustRequestService, dialogService, configurationService, lifecycleService) {
         super();
         this.context = context;
         this.requests = requests;
         this.telemetryService = telemetryService;
         this.authenticationService = authenticationService;
+        this.authenticationExtensionsService = authenticationExtensionsService;
         this.viewsService = viewsService;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.productService = productService;
@@ -574,13 +650,19 @@ let ChatSetupController = class ChatSetupController extends Disposable {
         this.activityService = activityService;
         this.commandService = commandService;
         this.layoutService = layoutService;
+        this.workspaceTrustRequestService = workspaceTrustRequestService;
+        this.dialogService = dialogService;
+        this.configurationService = configurationService;
+        this.lifecycleService = lifecycleService;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
         this._step = ChatSetupStep.Initial;
+        this.willShutdown = false;
         this.registerListeners();
     }
     registerListeners() {
         this._register(this.context.onDidChange(() => this._onDidChange.fire()));
+        this._register(this.lifecycleService.onWillShutdown(() => this.willShutdown = true));
     }
     setStep(step) {
         if (this._step === step) {
@@ -589,47 +671,50 @@ let ChatSetupController = class ChatSetupController extends Disposable {
         this._step = step;
         this._onDidChange.fire();
     }
-    async setup() {
-        const title = ( localize(4551, "Getting Copilot ready..."));
-        const badge = this.activityService.showViewContainerActivity(isCopilotEditsViewActive(this.viewsService) ? CHAT_EDITING_SIDEBAR_PANEL_ID : CHAT_SIDEBAR_PANEL_ID, {
+    async setup(options) {
+        const watch = ( new StopWatch(false));
+        const title = ( localize(4654, "Getting Copilot ready..."));
+        const badge = this.activityService.showViewContainerActivity(preferCopilotEditsView(this.viewsService) ? CHAT_EDITING_SIDEBAR_PANEL_ID : CHAT_SIDEBAR_PANEL_ID, {
             badge: ( new ProgressBadge(() => title)),
-            priority: 100
         });
         try {
             await this.progressService.withProgress({
                 location: ProgressLocation.Window,
                 command: TRIGGER_SETUP_COMMAND_ID,
                 title,
-            }, () => this.doSetup());
+            }, () => this.doSetup(options?.forceSignIn ?? false, watch));
         }
         finally {
             badge.dispose();
         }
     }
-    async doSetup() {
+    async doSetup(forceSignIn, watch) {
         this.context.suspend();
         let focusChatInput = false;
         try {
+            const providerId = ChatSetupRequests.providerId(this.configurationService);
             let session;
             let entitlement;
-            if (this.context.state.entitlement === ChatEntitlement.Unknown) {
+            if (this.context.state.entitlement === ChatEntitlement.Unknown || forceSignIn) {
                 this.setStep(ChatSetupStep.SigningIn);
-                const result = await this.signIn();
+                const result = await this.signIn(providerId);
                 if (!result.session) {
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotSignedIn', installDuration: watch.elapsed(), signUpErrorCode: undefined });
                     return;
                 }
                 session = result.session;
                 entitlement = result.entitlement;
             }
-            if (!session) {
-                session = (await this.authenticationService.getSessions(defaultChat.providerIds[0])).at(0);
-                if (!session) {
-                    return;
-                }
+            const trusted = await this.workspaceTrustRequestService.requestWorkspaceTrust({
+                message: ( localize(4655, "Copilot is currently only supported in trusted workspaces."))
+            });
+            if (!trusted) {
+                this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotTrusted', installDuration: watch.elapsed(), signUpErrorCode: undefined });
+                return;
             }
             const activeElement = getActiveElement();
             this.setStep(ChatSetupStep.Installing);
-            await this.install(session, entitlement ?? this.context.state.entitlement);
+            await this.install(session, entitlement ?? this.context.state.entitlement, providerId, watch);
             const currentActiveElement = getActiveElement();
             focusChatInput = activeElement === currentActiveElement || currentActiveElement === mainWindow.document.body;
         }
@@ -641,128 +726,183 @@ let ChatSetupController = class ChatSetupController extends Disposable {
             (await showCopilotView(this.viewsService, this.layoutService))?.focusInput();
         }
     }
-    async signIn() {
+    async signIn(providerId) {
         let session;
         let entitlement;
         try {
             showCopilotView(this.viewsService, this.layoutService);
-            session = await this.authenticationService.createSession(defaultChat.providerIds[0], defaultChat.providerScopes[0]);
+            session = await this.authenticationService.createSession(providerId, defaultChat.providerScopes[0]);
+            this.authenticationExtensionsService.updateAccountPreference(defaultChat.extensionId, providerId, session.account);
+            this.authenticationExtensionsService.updateAccountPreference(defaultChat.chatExtensionId, providerId, session.account);
             entitlement = await this.requests.forceResolveEntitlement(session);
         }
-        catch (error) {
+        catch (e) {
+            this.logService.error(`[chat setup] signIn: error ${e}`);
         }
-        if (!session) {
-            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotSignedIn', signedIn: false });
+        if (!session && !this.willShutdown) {
+            const { confirmed } = await this.dialogService.confirm({
+                type: Severity.Error,
+                message: ( localize(
+                    4656,
+                    "Failed to sign in to {0}. Would you like to try again?",
+                    ChatSetupRequests.providerId(this.configurationService) === defaultChat.enterpriseProviderId ? defaultChat.enterpriseProviderName : defaultChat.providerName
+                )),
+                detail: ( localize(4657, "You must be signed in to use Copilot.")),
+                primaryButton: ( localize(4650, "Retry"))
+            });
+            if (confirmed) {
+                return this.signIn(providerId);
+            }
         }
         return { session, entitlement };
     }
-    async install(session, entitlement) {
-        const signedIn = !!session;
-        let installResult = undefined;
+    async install(session, entitlement, providerId, watch) {
         const wasInstalled = this.context.state.installed;
-        let didSignUp = false;
+        let signUpResult = undefined;
         try {
             showCopilotView(this.viewsService, this.layoutService);
-            if (entitlement !== ChatEntitlement.Limited && entitlement !== ChatEntitlement.Pro && entitlement !== ChatEntitlement.Unavailable) {
-                didSignUp = await this.requests.signUpLimited(session);
-                if (!didSignUp) {
-                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedSignUp', signedIn });
+            if (entitlement !== ChatEntitlement.Limited &&
+                entitlement !== ChatEntitlement.Pro &&
+                entitlement !== ChatEntitlement.Unavailable
+            ) {
+                if (!session) {
+                    try {
+                        session = (await this.authenticationService.getSessions(providerId)).at(0);
+                    }
+                    catch (error) {
+                    }
+                    if (!session) {
+                        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNoSession', installDuration: watch.elapsed(), signUpErrorCode: undefined });
+                        return;
+                    }
+                }
+                signUpResult = await this.requests.signUpLimited(session);
+                if (typeof signUpResult !== 'boolean' ) {
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedSignUp', installDuration: watch.elapsed(), signUpErrorCode: signUpResult.errorCode });
                 }
             }
+            await this.doInstall();
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] install: error ${error}`);
+            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: isCancellationError(error) ? 'cancelled' : 'failedInstall', installDuration: watch.elapsed(), signUpErrorCode: undefined });
+            return;
+        }
+        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'installed', installDuration: watch.elapsed(), signUpErrorCode: undefined });
+        if (wasInstalled && signUpResult === true) {
+            refreshTokens(this.commandService);
+        }
+        await Promise.race([
+            timeout(5000),
+            Event.toPromise(this.chatAgentService.onDidChangeAgents)
+        ]);
+    }
+    async doInstall() {
+        let error;
+        try {
             await this.extensionsWorkbenchService.install(defaultChat.extensionId, {
                 enable: true,
+                isApplicationScoped: true,
                 isMachineScoped: false,
                 installEverywhere: true,
                 installPreReleaseVersion: this.productService.quality !== 'stable'
-            }, isCopilotEditsViewActive(this.viewsService) ? EditsViewId : ChatViewId);
-            installResult = 'installed';
+            }, preferCopilotEditsView(this.viewsService) ? EditsViewId : ChatViewId);
         }
-        catch (error) {
+        catch (e) {
             this.logService.error(`[chat setup] install: error ${error}`);
-            installResult = isCancellationError(error) ? 'cancelled' : 'failedInstall';
+            error = e;
         }
-        finally {
-            if (wasInstalled && didSignUp) {
-                this.commandService.executeCommand('github.copilot.refreshToken');
-            }
-            if (installResult === 'installed') {
-                await Promise.race([
-                    timeout(5000),
-                    Event.toPromise(this.chatAgentService.onDidChangeAgents)
-                ]);
+        if (error) {
+            if (!this.willShutdown) {
+                const { confirmed } = await this.dialogService.confirm({
+                    type: Severity.Error,
+                    message: ( localize(
+                        4658,
+                        "An error occurred while setting up Copilot. Would you like to try again?"
+                    )),
+                    detail: error && !isCancellationError(error) ? toErrorMessage(error) : undefined,
+                    primaryButton: ( localize(4650, "Retry"))
+                });
+                if (confirmed) {
+                    return this.doInstall();
+                }
             }
+            throw error;
         }
-        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult, signedIn });
     }
 };
 ChatSetupController = ( __decorate([
     ( __param(2, ITelemetryService)),
     ( __param(3, IAuthenticationService)),
-    ( __param(4, IViewsService)),
-    ( __param(5, IExtensionsWorkbenchService)),
-    ( __param(6, IProductService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IProgressService)),
-    ( __param(9, IChatAgentService)),
-    ( __param(10, IActivityService)),
-    ( __param(11, ICommandService)),
-    ( __param(12, IWorkbenchLayoutService))
+    ( __param(4, IAuthenticationExtensionsService)),
+    ( __param(5, IViewsService)),
+    ( __param(6, IExtensionsWorkbenchService)),
+    ( __param(7, IProductService)),
+    ( __param(8, ILogService)),
+    ( __param(9, IProgressService)),
+    ( __param(10, IChatAgentService)),
+    ( __param(11, IActivityService)),
+    ( __param(12, ICommandService)),
+    ( __param(13, IWorkbenchLayoutService)),
+    ( __param(14, IWorkspaceTrustRequestService)),
+    ( __param(15, IDialogService)),
+    ( __param(16, IConfigurationService)),
+    ( __param(17, ILifecycleService))
 ], ChatSetupController));
 let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
-    constructor(controller, context, instantiationService, contextMenuService, commandService, telemetryService) {
+    constructor(controller, context, instantiationService, contextMenuService, configurationService, telemetryService, quickInputService, dialogService) {
         super();
         this.controller = controller;
         this.context = context;
         this.instantiationService = instantiationService;
         this.contextMenuService = contextMenuService;
-        this.commandService = commandService;
+        this.configurationService = configurationService;
         this.telemetryService = telemetryService;
+        this.quickInputService = quickInputService;
+        this.dialogService = dialogService;
         this.element = $('.chat-setup-view');
         this.create();
     }
     create() {
-        const markdown = this._register(this.instantiationService.createInstance(MarkdownRenderer, {}));
+        const markdown = this.instantiationService.createInstance(MarkdownRenderer, {});
         {
             const header = ( localize(
-                4552,
+                4659,
                 "[Copilot]({0}) is your AI pair programmer.",
                 this.context.state.installed ? 'command:github.copilot.open.walkthrough' : defaultChat.documentationUrl
             ));
             this.element.appendChild($('p')).appendChild(this._register(markdown.render(( new MarkdownString(header, { isTrusted: true })))).element);
-            const features = this.element.appendChild($('div.chat-features-container'));
-            this.element.appendChild(features);
-            const featureChatContainer = features.appendChild($('div.chat-feature-container'));
+            const featuresParent = this.element.appendChild($('div.chat-features-container'));
+            this.element.appendChild(featuresParent);
+            const featuresContainer = this.element.appendChild($('div'));
+            featuresParent.appendChild(featuresContainer);
+            const featureChatContainer = featuresContainer.appendChild($('div.chat-feature-container'));
             featureChatContainer.appendChild(renderIcon(Codicon.code));
             const featureChatLabel = featureChatContainer.appendChild($('span'));
-            featureChatLabel.textContent = ( localize(4553, "Code faster with completions and Inline Chat"));
-            const featureEditsContainer = features.appendChild($('div.chat-feature-container'));
+            featureChatLabel.textContent = ( localize(4660, "Code faster with Completions"));
+            const featureEditsContainer = featuresContainer.appendChild($('div.chat-feature-container'));
             featureEditsContainer.appendChild(renderIcon(Codicon.editSession));
             const featureEditsLabel = featureEditsContainer.appendChild($('span'));
-            featureEditsLabel.textContent = ( localize(4554, "Build features and resolve bugs with Copilot Edits"));
-            const featureExploreContainer = features.appendChild($('div.chat-feature-container'));
+            featureEditsLabel.textContent = ( localize(4661, "Build features with Copilot Edits"));
+            const featureExploreContainer = featuresContainer.appendChild($('div.chat-feature-container'));
             featureExploreContainer.appendChild(renderIcon(Codicon.commentDiscussion));
             const featureExploreLabel = featureExploreContainer.appendChild($('span'));
-            featureExploreLabel.textContent = ( localize(4555, "Explore your codebase with chat"));
+            featureExploreLabel.textContent = ( localize(4662, "Explore your codebase with Chat"));
         }
         const free = ( localize(
-            4556,
+            4663,
             "$(sparkle-filled) We now offer [Copilot for free]({0}).",
             defaultChat.skusDocumentationUrl
         ));
         const freeContainer = this.element.appendChild($('p'));
         freeContainer.appendChild(this._register(markdown.render(( new MarkdownString(free, { isTrusted: true, supportThemeIcons: true })))).element);
-        const actions = [];
-        if (this.context.state.installed) {
-            actions.push(toAction({ id: 'chatSetup.signInGh', label: ( localize(4557, "Sign in with a GitHub.com Account")), run: () => this.commandService.executeCommand('github.copilotChat.signIn') }));
-            actions.push(toAction({ id: 'chatSetup.signInGhe', label: ( localize(4558, "Sign in with a GHE.com Account")), run: () => this.commandService.executeCommand('github.copilotChat.signInGHE') }));
-        }
         const buttonContainer = this.element.appendChild($('p'));
         buttonContainer.classList.add('button-container');
-        const button = this._register(actions.length === 0 ? ( new Button(buttonContainer, {
-            supportIcons: true,
-            ...defaultButtonStyles
-        })) : ( new ButtonWithDropdown(buttonContainer, {
-            actions,
+        const button = this._register(( new ButtonWithDropdown(buttonContainer, {
+            actions: [
+                toAction({ id: 'chatSetup.setupWithProvider', label: ( localize(4664, "Sign in with a {0} Account", defaultChat.providerName)), run: () => this.setupWithProvider(false) }),
+                toAction({ id: 'chatSetup.setupWithEnterpriseProvider', label: ( localize(4665, "Sign in with a {0} Account", defaultChat.enterpriseProviderName)), run: () => this.setupWithProvider(true) })
+            ],
             addPrimaryActionToDropdown: false,
             contextMenuProvider: this.contextMenuService,
             supportIcons: true,
@@ -770,14 +910,14 @@ let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
         })));
         this._register(button.onDidClick(() => this.controller.setup()));
         const terms = ( localize(
-            4559,
+            4666,
             "By continuing, you agree to the [Terms]({0}) and [Privacy Policy]({1}).",
             defaultChat.termsStatementUrl,
             defaultChat.privacyStatementUrl
         ));
         this.element.appendChild($('p')).appendChild(this._register(markdown.render(( new MarkdownString(terms, { isTrusted: true })))).element);
         const settings = ( localize(
-            4560,
+            4667,
             "Copilot Free and Pro may show [public code]({0}) suggestions and we may use your data for product improvement. You can change these [settings]({1}) at any time.",
             defaultChat.publicCodeMatchesUrl,
             defaultChat.manageSettingsUrl
@@ -793,29 +933,33 @@ let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
         switch (this.context.state.entitlement) {
             case ChatEntitlement.Unknown:
                 showFree = true;
-                buttonLabel = this.context.state.registered ? ( localize(4561, "Sign in to Use Copilot")) : ( localize(4562, "Sign in to Use Copilot for Free"));
+                buttonLabel = this.context.state.registered ? ( localize(4668, "Sign in to Use Copilot")) : ( localize(4669, "Sign in to Use Copilot for Free"));
                 break;
             case ChatEntitlement.Unresolved:
                 showFree = true;
-                buttonLabel = this.context.state.registered ? ( localize(4563, "Use Copilot")) : ( localize(4564, "Use Copilot for Free"));
+                buttonLabel = this.context.state.registered ? ( localize(4670, "Use Copilot")) : ( localize(4671, "Use Copilot for Free"));
                 break;
             case ChatEntitlement.Available:
             case ChatEntitlement.Limited:
                 showFree = true;
-                buttonLabel = ( localize(4564, "Use Copilot for Free"));
+                buttonLabel = ( localize(4671, "Use Copilot for Free"));
                 break;
             case ChatEntitlement.Pro:
             case ChatEntitlement.Unavailable:
                 showFree = false;
-                buttonLabel = ( localize(4563, "Use Copilot"));
+                buttonLabel = ( localize(4670, "Use Copilot"));
                 break;
         }
         switch (this.controller.step) {
             case ChatSetupStep.SigningIn:
-                buttonLabel = ( localize(4565, "$(loading~spin) Signing in to {0}...", defaultChat.providerName));
+                buttonLabel = ( localize(
+                    4672,
+                    "$(loading~spin) Signing in to {0}...",
+                    ChatSetupRequests.providerId(this.configurationService) === defaultChat.enterpriseProviderId ? defaultChat.enterpriseProviderName : defaultChat.providerName
+                ));
                 break;
             case ChatSetupStep.Installing:
-                buttonLabel = ( localize(4566, "$(loading~spin) Getting Copilot Ready..."));
+                buttonLabel = ( localize(4673, "$(loading~spin) Getting Copilot Ready..."));
                 break;
         }
         setVisibility(showFree, freeContainer);
@@ -823,12 +967,107 @@ let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
         button.label = buttonLabel;
         button.enabled = this.controller.step === ChatSetupStep.Initial;
     }
+    async setupWithProvider(useEnterpriseProvider) {
+        const registry = ( Registry.as(Extensions.Configuration));
+        registry.registerConfiguration({
+            'id': 'copilot.setup',
+            'type': 'object',
+            'properties': {
+                [defaultChat.providerSetting]: {
+                    'type': 'string'
+                },
+                [defaultChat.providerUriSetting]: {
+                    'type': 'string'
+                }
+            }
+        });
+        if (useEnterpriseProvider) {
+            await this.configurationService.updateValue(defaultChat.providerSetting, defaultChat.enterpriseProviderId, ConfigurationTarget.USER);
+            const success = await this.handleEnterpriseInstance();
+            if (!success) {
+                return;
+            }
+        }
+        else {
+            await this.configurationService.updateValue(defaultChat.providerSetting, undefined, ConfigurationTarget.USER);
+            await this.configurationService.updateValue(defaultChat.providerUriSetting, undefined, ConfigurationTarget.USER);
+        }
+        return this.controller.setup({ forceSignIn: true });
+    }
+    async handleEnterpriseInstance() {
+        const uri = this.configurationService.getValue(defaultChat.providerUriSetting);
+        if (uri) {
+            return true;
+        }
+        let isSingleWord = false;
+        const result = await this.quickInputService.input({
+            prompt: ( localize(4674, "What is your {0} instance?", defaultChat.enterpriseProviderName)),
+            placeHolder: ( localize(4675, 'i.e. "octocat" or "https://octocat.ghe.com"...')),
+            validateInput: async (value) => {
+                isSingleWord = false;
+                if (!value) {
+                    return undefined;
+                }
+                if (/^[a-zA-Z\-_]+$/.test(value)) {
+                    isSingleWord = true;
+                    return {
+                        content: ( localize(4676, "Will resolve to {0}", `https://${value}.ghe.com`)),
+                        severity: Severity.Info
+                    };
+                }
+                else {
+                    const regex = /^(https:\/\/)?([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.ghe\.com\/?$/;
+                    if (!regex.test(value)) {
+                        return {
+                            content: ( localize(
+                                4677,
+                                'Please enter a valid {0} instance (i.e. "octocat" or "https://octocat.ghe.com")',
+                                defaultChat.enterpriseProviderName
+                            )),
+                            severity: Severity.Error
+                        };
+                    }
+                }
+                return undefined;
+            }
+        });
+        if (!result) {
+            const { confirmed } = await this.dialogService.confirm({
+                type: Severity.Error,
+                message: ( localize(
+                    4678,
+                    "The provided {0} instance is invalid. Would you like to enter it again?",
+                    defaultChat.enterpriseProviderName
+                )),
+                primaryButton: ( localize(4650, "Retry"))
+            });
+            if (confirmed) {
+                return this.handleEnterpriseInstance();
+            }
+            return false;
+        }
+        let resolvedUri = result;
+        if (isSingleWord) {
+            resolvedUri = `https://${resolvedUri}.ghe.com`;
+        }
+        else {
+            const normalizedUri = result.toLowerCase();
+            const hasHttps = normalizedUri.startsWith('https://');
+            if (!hasHttps) {
+                resolvedUri = `https://${result}`;
+            }
+        }
+        await this.configurationService.updateValue(defaultChat.providerUriSetting, resolvedUri, ConfigurationTarget.USER);
+        return true;
+    }
 };
 ChatSetupWelcomeContent = ( __decorate([
     ( __param(2, IInstantiationService)),
     ( __param(3, IContextMenuService)),
-    ( __param(4, ICommandService)),
-    ( __param(5, ITelemetryService))
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ITelemetryService)),
+    ( __param(6, IQuickInputService)),
+    ( __param(7, IDialogService))
 ], ChatSetupWelcomeContent));
 let ChatSetupContext = class ChatSetupContext extends Disposable {
     static { ChatSetupContext_1 = this; }
@@ -836,19 +1075,19 @@ let ChatSetupContext = class ChatSetupContext extends Disposable {
     get state() {
         return this.suspendedState ?? this._state;
     }
-    constructor(contextKeyService, storageService, workspaceContextService, extensionService, extensionEnablementService, logService, extensionsWorkbenchService) {
+    constructor(contextKeyService, storageService, workspaceContextService, extensionEnablementService, logService, extensionsWorkbenchService) {
         super();
         this.contextKeyService = contextKeyService;
         this.storageService = storageService;
         this.workspaceContextService = workspaceContextService;
-        this.extensionService = extensionService;
         this.extensionEnablementService = extensionEnablementService;
         this.logService = logService;
         this.extensionsWorkbenchService = extensionsWorkbenchService;
         this.canSignUpContextKey = ChatContextKeys.Setup.canSignUp.bindTo(this.contextKeyService);
         this.signedOutContextKey = ChatContextKeys.Setup.signedOut.bindTo(this.contextKeyService);
         this.limitedContextKey = ChatContextKeys.Setup.limited.bindTo(this.contextKeyService);
-        this.triggeredContext = ChatContextKeys.Setup.triggered.bindTo(this.contextKeyService);
+        this.proContextKey = ChatContextKeys.Setup.pro.bindTo(this.contextKeyService);
+        this.hiddenContext = ChatContextKeys.Setup.hidden.bindTo(this.contextKeyService);
         this.installedContext = ChatContextKeys.Setup.installed.bindTo(this.contextKeyService);
         this._state = this.storageService.getObject(ChatSetupContext_1.CHAT_SETUP_CONTEXT_STORAGE_KEY, StorageScope.PROFILE) ?? { entitlement: ChatEntitlement.Unknown };
         this.suspendedState = undefined;
@@ -859,34 +1098,25 @@ let ChatSetupContext = class ChatSetupContext extends Disposable {
         this.updateContextSync();
     }
     async checkExtensionInstallation() {
-        this._register(this.extensionService.onDidChangeExtensions(result => {
-            for (const extension of result.removed) {
-                if (ExtensionIdentifier.equals(defaultChat.extensionId, extension.identifier)) {
-                    this.update({ installed: false });
-                    break;
-                }
-            }
-            for (const extension of result.added) {
-                if (ExtensionIdentifier.equals(defaultChat.extensionId, extension.identifier)) {
-                    this.update({ installed: true });
-                    break;
-                }
+        await this.extensionsWorkbenchService.queryLocal();
+        this._register(Event.runAndSubscribe(this.extensionsWorkbenchService.onChange, e => {
+            if (e && !ExtensionIdentifier.equals(e.identifier.id, defaultChat.extensionId)) {
+                return;
             }
+            const defaultChatExtension = this.extensionsWorkbenchService.local.find(value => ExtensionIdentifier.equals(value.identifier.id, defaultChat.extensionId));
+            this.update({ installed: !!defaultChatExtension?.local && this.extensionEnablementService.isEnabled(defaultChatExtension.local) });
         }));
-        const extensions = await this.extensionsWorkbenchService.queryLocal();
-        const defaultChatExtension = extensions.find(value => ExtensionIdentifier.equals(value.identifier.id, defaultChat.extensionId));
-        this.update({ installed: !!defaultChatExtension?.local && this.extensionEnablementService.isEnabled(defaultChatExtension.local) });
     }
     update(context) {
         this.logService.trace(`[chat setup] update(): ${JSON.stringify(context)}`);
         if (typeof context.installed === 'boolean') {
             this._state.installed = context.installed;
             if (context.installed) {
-                context.triggered = true;
+                context.hidden = false;
             }
         }
-        if (typeof context.triggered === 'boolean') {
-            this._state.triggered = context.triggered;
+        if (typeof context.hidden === 'boolean') {
+            this._state.hidden = context.hidden;
         }
         if (typeof context.entitlement === 'number') {
             this._state.entitlement = context.entitlement;
@@ -906,14 +1136,15 @@ let ChatSetupContext = class ChatSetupContext extends Disposable {
     }
     updateContextSync() {
         this.logService.trace(`[chat setup] updateContext(): ${JSON.stringify(this._state)}`);
-        if (this._state.triggered && !this._state.installed) {
+        if (!this._state.hidden && !this._state.installed) {
             this.storageService.remove('chat.welcomeMessageContent.panel', StorageScope.APPLICATION);
             this.storageService.remove('interactive.sessions', this.workspaceContextService.getWorkspace().folders.length ? StorageScope.WORKSPACE : StorageScope.APPLICATION);
         }
         this.signedOutContextKey.set(this._state.entitlement === ChatEntitlement.Unknown);
         this.canSignUpContextKey.set(this._state.entitlement === ChatEntitlement.Available);
         this.limitedContextKey.set(this._state.entitlement === ChatEntitlement.Limited);
-        this.triggeredContext.set(!!this._state.triggered);
+        this.proContextKey.set(this._state.entitlement === ChatEntitlement.Pro);
+        this.hiddenContext.set(!!this._state.hidden);
         this.installedContext.set(!!this._state.installed);
         this._onDidChange.fire();
     }
@@ -931,24 +1162,13 @@ ChatSetupContext = ChatSetupContext_1 = ( __decorate([
     ( __param(0, IContextKeyService)),
     ( __param(1, IStorageService)),
     ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, IWorkbenchExtensionEnablementService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IExtensionsWorkbenchService))
+    ( __param(3, IWorkbenchExtensionEnablementService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IExtensionsWorkbenchService))
 ], ChatSetupContext));
-function isCopilotEditsViewActive(viewsService) {
-    return viewsService.getFocusedView()?.id === EditsViewId;
-}
-function showCopilotView(viewsService, layoutService) {
-    if (layoutService.activeContainer !== layoutService.mainContainer) {
-        layoutService.mainContainer.focus();
-    }
-    if (isCopilotEditsViewActive(viewsService)) {
-        return showEditsView(viewsService);
-    }
-    else {
-        return showChatView(viewsService);
-    }
+function refreshTokens(commandService) {
+    commandService.executeCommand('github.copilot.signIn');
+    commandService.executeCommand('github.copilot.refreshToken');
 }
 
-export { SetupWelcomeViewCondition, SetupWelcomeViewKeys };
+export { ChatSetupContribution };