@codingame/monaco-vscode-chat-service-override 15.0.2 → 16.0.0

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

@@ -1,82 +1,79 @@
 
 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 './media/chatSetup.css';
+import { $, getActiveElement, setVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 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 { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
 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 { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
 import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Emitter, Event } 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';
+import { Disposable, DisposableStore, markAsSingleton, MutableDisposable, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+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 { localize, localize2 } 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 { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
 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';
 import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
 import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
-import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
 import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
-import { asText } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
-import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
-import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { TelemetryLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { 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-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, 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 { Parts } from '@codingame/monaco-vscode-81f603ca-d6ea-5402-90dd-3014dffc63b4-common/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { ExtensionUrlHandlerOverrideRegistry } from '@codingame/monaco-vscode-8c844347-a703-5de1-9eeb-5e0c7f503a58-common/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
+import { nullExtensionDescription } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { Parts } from '@codingame/monaco-vscode-b1110435-a331-5549-ab1e-aa3d763c3a1f-common/vscode/vs/workbench/services/layout/browser/layoutService';
 import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IStatusbarService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/statusbar/browser/statusbar.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, CHAT_SETUP_ACTION_LABEL, CHAT_SETUP_ACTION_ID } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ChatEntitlement, ChatEntitlementRequests } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEntitlementService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { CHAT_SETUP_ACTION_ID, CHAT_CATEGORY, CHAT_OPEN_ACTION_ID } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 import { showCopilotView, ensureSideBarChatViewSize, ChatViewId, preferCopilotEditsView, EditsViewId } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-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_EDITING_SIDEBAR_PANEL_ID, CHAT_SIDEBAR_PANEL_ID } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatViewPane';
 import { ChatViewsWelcomeExtensions } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
-import { IChatQuotasService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatQuotasService.service';
-import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
-import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
-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';
-import { ChatEntitlement } from '../common/chatEntitlementsService.js';
-import { IChatEntitlementsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEntitlementsService.service';
-import { IStatusbarService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/statusbar/browser/statusbar.service';
+import { ChatConfiguration, ChatAgentLocation, validateChatMode } 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 { Dialog } from '@codingame/monaco-vscode-f1bbc6d3-6129-583c-a2ba-c80b832993d2-common/vscode/vs/base/browser/ui/dialog/dialog';
+import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { createWorkbenchDialogOptions } from '@codingame/monaco-vscode-f1bbc6d3-6129-583c-a2ba-c80b832993d2-common/vscode/vs/platform/dialogs/browser/dialog';
 
-var ChatSetupRequests_1, ChatSetupContext_1;
+var SetupChatAgentImplementation_1, ChatSetup_1;
 const defaultChat = {
     extensionId: product.defaultChatAgent?.extensionId ?? '',
     chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
@@ -86,73 +83,467 @@ const defaultChat = {
     skusDocumentationUrl: product.defaultChatAgent?.skusDocumentationUrl ?? '',
     publicCodeMatchesUrl: product.defaultChatAgent?.publicCodeMatchesUrl ?? '',
     upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',
-    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 ?? '',
     manageSettingsUrl: product.defaultChatAgent?.manageSettingsUrl ?? '',
+    completionsAdvancedSetting: product.defaultChatAgent?.completionsAdvancedSetting ?? '',
+    walkthroughCommand: product.defaultChatAgent?.walkthroughCommand ?? '',
+    completionsRefreshTokenCommand: product.defaultChatAgent?.completionsRefreshTokenCommand ?? '',
+    chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? '',
 };
-let ChatEntitlementsService = class ChatEntitlementsService extends Disposable {
-    constructor(instantiationService, productService, environmentService) {
+const ToolsAgentWhen = ( ContextKeyExpr.and(( ContextKeyExpr.equals(`config.${ChatConfiguration.AgentEnabled}`, true)), ( ChatContextKeys.Editing.agentModeDisallowed.negate()),
+ContextKeyExpr.not(`previewFeaturesDisabled`)));
+let SetupChatAgentImplementation = class SetupChatAgentImplementation extends Disposable {
+    static { SetupChatAgentImplementation_1 = this; }
+    static register(instantiationService, location, isToolsAgent, context, controller) {
+        return instantiationService.invokeFunction(accessor => {
+            const chatAgentService = accessor.get(IChatAgentService);
+            let id;
+            let description = ( localize(4785, "Ask Copilot"));
+            let welcomeMessageContent;
+            const baseMessage = ( localize(
+                4786,
+                "Copilot is powered by AI, so mistakes are possible. Review output carefully before use."
+            ));
+            switch (location) {
+                case ChatAgentLocation.Panel:
+                    id = 'setup.chat';
+                    welcomeMessageContent = {
+                        title: description,
+                        message: ( new MarkdownString(baseMessage)),
+                        icon: Codicon.copilotLarge
+                    };
+                    break;
+                case ChatAgentLocation.EditingSession:
+                    id = isToolsAgent ? 'setup.agent' : 'setup.edits';
+                    description = isToolsAgent ? ( localize(4787, "Edit files in your workspace in agent mode")) : ( localize(4788, "Edit files in your workspace"));
+                    welcomeMessageContent = isToolsAgent ?
+                        {
+                            title: ( localize(4789, "Edit with Copilot")),
+                            message: ( new MarkdownString(( localize(
+                                4790,
+                                "Ask Copilot to edit your files in [agent mode]({0}). Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.",
+                                `https://aka.ms/vscode-copilot-agent`
+                            )) + `\n\n${baseMessage}`)),
+                            icon: Codicon.copilotLarge
+                        } :
+                        {
+                            title: ( localize(4789, "Edit with Copilot")),
+                            message: ( new MarkdownString(( localize(
+                                4791,
+                                "Start your editing session by defining a set of files that you want to work with. Then ask Copilot for the changes you want to make."
+                            )) + `\n\n${baseMessage}`)),
+                            icon: Codicon.copilotLarge
+                        };
+                    break;
+                case ChatAgentLocation.Terminal:
+                    id = 'setup.terminal';
+                    break;
+                case ChatAgentLocation.Editor:
+                    id = 'setup.editor';
+                    break;
+                case ChatAgentLocation.Notebook:
+                    id = 'setup.notebook';
+                    break;
+            }
+            const disposable = ( new DisposableStore());
+            disposable.add(chatAgentService.registerAgent(id, {
+                id,
+                name: `${defaultChat.providerName} Copilot`,
+                isDefault: true,
+                isCore: true,
+                isToolsAgent,
+                when: isToolsAgent ? ToolsAgentWhen?.serialize() : undefined,
+                slashCommands: [],
+                disambiguation: [],
+                locations: [location],
+                metadata: {
+                    welcomeMessageContent,
+                    helpTextPrefix: SetupChatAgentImplementation_1.SETUP_NEEDED_MESSAGE
+                },
+                description,
+                extensionId: nullExtensionDescription.identifier,
+                extensionDisplayName: nullExtensionDescription.name,
+                extensionPublisherId: nullExtensionDescription.publisher
+            }));
+            const agent = disposable.add(instantiationService.createInstance(SetupChatAgentImplementation_1, context, controller, location));
+            disposable.add(chatAgentService.registerAgentImplementation(id, agent));
+            return { agent, disposable };
+        });
+    }
+    static { this.SETUP_NEEDED_MESSAGE = ( new MarkdownString(( localize(4792, "You need to set up Copilot to use Chat.")))); }
+    constructor(context, controller, location, instantiationService, logService, configurationService, telemetryService) {
         super();
-        if (!productService.defaultChatAgent ||
-            (isWeb && !environmentService.remoteAuthority)
-        ) {
+        this.context = context;
+        this.controller = controller;
+        this.location = location;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
+        this._onUnresolvableError = this._register(( new Emitter()));
+        this.onUnresolvableError = this._onUnresolvableError.event;
+    }
+    async invoke(request, progress) {
+        return this.instantiationService.invokeFunction(async (accessor) => {
+            const chatService = accessor.get(IChatService);
+            const languageModelsService = accessor.get(ILanguageModelsService);
+            const chatWidgetService = accessor.get(IChatWidgetService);
+            const chatAgentService = accessor.get(IChatAgentService);
+            return this.doInvoke(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService);
+        });
+    }
+    async doInvoke(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService) {
+        if (!this.context.state.installed || this.context.state.entitlement === ChatEntitlement.Available || this.context.state.entitlement === ChatEntitlement.Unknown) {
+            return this.doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService);
+        }
+        return this.doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService);
+    }
+    async doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService) {
+        const requestModel = chatWidgetService.getWidgetBySessionId(request.sessionId)?.viewModel?.model.getRequests().at(-1);
+        if (!requestModel) {
+            this.logService.error('[chat setup] Request model not found, cannot redispatch request.');
+            return {};
+        }
+        progress({
+            kind: 'progressMessage',
+            content: ( new MarkdownString(( localize(4793, "Getting Copilot ready.")))),
+        });
+        await this.forwardRequestToCopilot(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService);
+        return {};
+    }
+    async forwardRequestToCopilot(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService) {
+        if (this._handlingForwardedRequest === requestModel.message.text) {
+            throw ( new Error('Already handling this request'));
+        }
+        this._handlingForwardedRequest = requestModel.message.text;
+        const whenLanguageModelReady = this.whenLanguageModelReady(languageModelsService);
+        const whenAgentReady = this.whenAgentReady(chatAgentService);
+        if (whenLanguageModelReady instanceof Promise || whenAgentReady instanceof Promise) {
+            const timeoutHandle = setTimeout(() => {
+                progress({
+                    kind: 'progressMessage',
+                    content: ( new MarkdownString(( localize(4794, "Copilot is almost ready.")))),
+                });
+            }, 10000);
+            try {
+                const ready = await Promise.race([
+                    timeout(20000).then(() => 'timedout'),
+                    Promise.allSettled([whenLanguageModelReady, whenAgentReady])
+                ]);
+                if (ready === 'timedout') {
+                    progress({
+                        kind: 'warning',
+                        content: ( new MarkdownString(( localize(4795, "Copilot took too long to get ready. Please try again."))))
+                    });
+                    this._onUnresolvableError.fire();
+                    return;
+                }
+            }
+            finally {
+                clearTimeout(timeoutHandle);
+            }
+        }
+        const widget = chatWidgetService.getWidgetBySessionId(requestModel.session.sessionId);
+        chatService.resendRequest(requestModel, {
+            mode: widget?.input.currentMode,
+            userSelectedModelId: widget?.input.currentLanguageModel,
+        });
+    }
+    whenLanguageModelReady(languageModelsService) {
+        for (const id of languageModelsService.getLanguageModelIds()) {
+            const model = languageModelsService.lookupLanguageModel(id);
+            if (model && model.isDefault) {
+                return;
+            }
+        }
+        return Event.toPromise(Event.filter(languageModelsService.onDidChangeLanguageModels, e => e.added?.some(added => added.metadata.isDefault) ?? false));
+    }
+    whenAgentReady(chatAgentService) {
+        const defaultAgent = chatAgentService.getDefaultAgent(this.location);
+        if (defaultAgent && !defaultAgent.isCore) {
             return;
         }
-        const context = this.context = ( new Lazy(
-            () => this._register(instantiationService.createInstance(ChatSetupContext))
+        return Event.toPromise(Event.filter(chatAgentService.onDidChangeAgents, () => {
+            const defaultAgent = chatAgentService.getDefaultAgent(this.location);
+            return Boolean(defaultAgent && !defaultAgent.isCore);
+        }));
+    }
+    async doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService) {
+        this.telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'chat' });
+        const requestModel = chatWidgetService.getWidgetBySessionId(request.sessionId)?.viewModel?.model.getRequests().at(-1);
+        const setupListener = Event.runAndSubscribe(this.controller.value.onDidChange, (() => {
+            switch (this.controller.value.step) {
+                case ChatSetupStep.SigningIn:
+                    progress({
+                        kind: 'progressMessage',
+                        content: ( new MarkdownString(( localize(
+                            4796,
+                            "Signing in to {0}.",
+                            ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.enterpriseProviderId ? defaultChat.enterpriseProviderName : defaultChat.providerName
+                        )))),
+                    });
+                    break;
+                case ChatSetupStep.Installing:
+                    progress({
+                        kind: 'progressMessage',
+                        content: ( new MarkdownString(( localize(4797, "Getting Copilot ready.")))),
+                    });
+                    break;
+            }
+        }));
+        let success = undefined;
+        try {
+            success = await ChatSetup.getInstance(this.instantiationService, this.context, this.controller).run();
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
+        }
+        finally {
+            setupListener.dispose();
+        }
+        if (typeof success === 'boolean') {
+            if (success) {
+                if (requestModel) {
+                    await this.forwardRequestToCopilot(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService);
+                }
+            }
+            else {
+                progress({
+                    kind: 'warning',
+                    content: ( new MarkdownString(( localize(4798, "Copilot setup failed."))))
+                });
+            }
+        }
+        else {
+            progress({
+                kind: 'markdownContent',
+                content: SetupChatAgentImplementation_1.SETUP_NEEDED_MESSAGE,
+            });
+        }
+        return {};
+    }
+};
+SetupChatAgentImplementation = SetupChatAgentImplementation_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ITelemetryService))
+], SetupChatAgentImplementation));
+var ChatSetupStrategy;
+(function (ChatSetupStrategy) {
+    ChatSetupStrategy[ChatSetupStrategy["Canceled"] = 0] = "Canceled";
+    ChatSetupStrategy[ChatSetupStrategy["DefaultSetup"] = 1] = "DefaultSetup";
+    ChatSetupStrategy[ChatSetupStrategy["SetupWithoutEnterpriseProvider"] = 2] = "SetupWithoutEnterpriseProvider";
+    ChatSetupStrategy[ChatSetupStrategy["SetupWithEnterpriseProvider"] = 3] = "SetupWithEnterpriseProvider";
+})(ChatSetupStrategy || (ChatSetupStrategy = {}));
+let ChatSetup = class ChatSetup {
+    static { ChatSetup_1 = this; }
+    static { this.instance = undefined; }
+    static getInstance(instantiationService, context, controller) {
+        let instance = ChatSetup_1.instance;
+        if (!instance) {
+            instance = ChatSetup_1.instance = instantiationService.invokeFunction(accessor => {
+                return ( new ChatSetup_1(
+                    context,
+                    controller,
+                    instantiationService,
+                    accessor.get(ITelemetryService),
+                    accessor.get(IContextMenuService),
+                    accessor.get(IWorkbenchLayoutService),
+                    accessor.get(IKeybindingService),
+                    accessor.get(IChatEntitlementService),
+                    accessor.get(ILogService)
+                ));
+            });
+        }
+        return instance;
+    }
+    constructor(context, controller, instantiationService, telemetryService, contextMenuService, layoutService, keybindingService, chatEntitlementService, logService) {
+        this.context = context;
+        this.controller = controller;
+        this.instantiationService = instantiationService;
+        this.telemetryService = telemetryService;
+        this.contextMenuService = contextMenuService;
+        this.layoutService = layoutService;
+        this.keybindingService = keybindingService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.logService = logService;
+        this.pendingRun = undefined;
+    }
+    async run() {
+        if (this.pendingRun) {
+            return this.pendingRun;
+        }
+        this.pendingRun = this.doRun();
+        try {
+            return await this.pendingRun;
+        }
+        finally {
+            this.pendingRun = undefined;
+        }
+    }
+    async doRun() {
+        let setupStrategy;
+        if (this.chatEntitlementService.entitlement === ChatEntitlement.Pro || this.chatEntitlementService.entitlement === ChatEntitlement.Limited) {
+            setupStrategy = ChatSetupStrategy.DefaultSetup;
+        }
+        else {
+            setupStrategy = await this.showDialog();
+        }
+        let success = undefined;
+        try {
+            switch (setupStrategy) {
+                case ChatSetupStrategy.SetupWithEnterpriseProvider:
+                    success = await this.controller.value.setupWithProvider({ setupFromDialog: true, useEnterpriseProvider: true });
+                    break;
+                case ChatSetupStrategy.SetupWithoutEnterpriseProvider:
+                    success = await this.controller.value.setupWithProvider({ setupFromDialog: true, useEnterpriseProvider: false });
+                    break;
+                case ChatSetupStrategy.DefaultSetup:
+                    success = await this.controller.value.setup({ setupFromDialog: true });
+                    break;
+            }
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
+            success = false;
+        }
+        return success;
+    }
+    async showDialog() {
+        const disposables = ( new DisposableStore());
+        let result = undefined;
+        const buttons = [this.getPrimaryButton(), ( localize(4799, "Maybe Later"))];
+        const dialog = disposables.add(( new Dialog(
+            this.layoutService.activeContainer,
+            this.getDialogTitle(),
+            buttons,
+            createWorkbenchDialogOptions({
+                type: 'none',
+                icon: Codicon.copilotLarge,
+                cancelId: buttons.length - 1,
+                renderBody: body => body.appendChild(this.createDialog(disposables)),
+                primaryButtonDropdown: {
+                    contextMenuProvider: this.contextMenuService,
+                    addPrimaryActionToDropdown: false,
+                    actions: [
+                        toAction({ id: 'setupWithProvider', label: ( localize(4800, "Sign in with a {0} Account", defaultChat.providerName)), run: () => result = ChatSetupStrategy.SetupWithoutEnterpriseProvider }),
+                        toAction({ id: 'setupWithEnterpriseProvider', label: ( localize(4801, "Sign in with a {0} Account", defaultChat.enterpriseProviderName)), run: () => result = ChatSetupStrategy.SetupWithEnterpriseProvider }),
+                    ]
+                }
+            }, this.keybindingService, this.layoutService)
+        )));
+        const { button } = await dialog.show();
+        disposables.dispose();
+        return button === 0 ? result ?? ChatSetupStrategy.DefaultSetup : ChatSetupStrategy.Canceled;
+    }
+    getPrimaryButton() {
+        if (this.context.state.entitlement === ChatEntitlement.Unknown) {
+            return localize(4802, "Sign in");
+        }
+        return localize(4803, "Use Copilot");
+    }
+    getDialogTitle() {
+        if (this.context.state.entitlement === ChatEntitlement.Unknown) {
+            return this.context.state.registered ? ( localize(4804, "Sign in to use Copilot")) : ( localize(4805, "Sign in to use Copilot for free"));
+        }
+        if (this.context.state.entitlement === ChatEntitlement.Pro) {
+            return localize(4806, "Start using Copilot Pro");
+        }
+        return this.context.state.registered ? ( localize(4807, "Start using Copilot")) : ( localize(4808, "Start using Copilot for free"));
+    }
+    createDialog(disposables) {
+        const element = $('.chat-setup-view');
+        const markdown = this.instantiationService.createInstance(MarkdownRenderer, {});
+        const header = ( localize(
+            4809,
+            "[Copilot]({0}) is your AI pair programmer. Write code faster with completions, fix bugs and build new features across multiple files, and learn about your codebase through chat.",
+            defaultChat.documentationUrl
         ));
-        this.requests = ( new Lazy(
-            () => this._register(instantiationService.createInstance(ChatSetupRequests, context.value))
+        element.appendChild($('p.setup-header', undefined, disposables.add(markdown.render(( new MarkdownString(header, { isTrusted: true })))).element));
+        const terms = ( localize(
+            4810,
+            "By continuing, you agree to the [Terms]({0}) and [Privacy Policy]({1}).",
+            defaultChat.termsStatementUrl,
+            defaultChat.privacyStatementUrl
         ));
-    }
-    async resolve(token) {
-        return this.requests?.value.forceResolveEntitlement(undefined, token);
+        element.appendChild($('p.setup-legal', undefined, disposables.add(markdown.render(( new MarkdownString(terms, { isTrusted: true })))).element));
+        if (this.telemetryService.telemetryLevel !== TelemetryLevel.NONE) {
+            const settings = ( localize(
+                4811,
+                "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
+            ));
+            element.appendChild($('p.setup-settings', undefined, disposables.add(markdown.render(( new MarkdownString(settings, { isTrusted: true })))).element));
+        }
+        return element;
     }
 };
-ChatEntitlementsService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IProductService)),
-    ( __param(2, IWorkbenchEnvironmentService))
-], ChatEntitlementsService));
+ChatSetup = ChatSetup_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, ILayoutService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, IChatEntitlementService)),
+    ( __param(8, ILogService))
+], ChatSetup));
 let ChatSetupContribution = class ChatSetupContribution extends Disposable {
-    static { this.ID = 'workbench.chat.setup'; }
-    constructor(productService, instantiationService, commandService, telemetryService, experimentService, chatEntitlementsService) {
+    static { this.ID = 'workbench.contrib.chatSetup'; }
+    constructor(productService, instantiationService, commandService, telemetryService, chatEntitlementService, configurationService, logService) {
         super();
         this.productService = productService;
         this.instantiationService = instantiationService;
         this.commandService = commandService;
         this.telemetryService = telemetryService;
-        this.experimentService = experimentService;
-        const context = chatEntitlementsService.context?.value;
-        const requests = chatEntitlementsService.requests?.value;
+        this.configurationService = configurationService;
+        this.logService = logService;
+        const context = chatEntitlementService.context?.value;
+        const requests = chatEntitlementService.requests?.value;
         if (!context || !requests) {
             return;
         }
         const controller = ( new Lazy(
             () => this._register(this.instantiationService.createInstance(ChatSetupController, context, requests))
         ));
-        this.registerChatWelcome(controller, context);
-        this.registerActions(context, requests);
+        this.registerSetupAgents(context, controller);
+        this.registerChatWelcome(context, controller);
+        this.registerActions(context, requests, controller);
         this.registerUrlLinkHandler();
-        this.registerSetting(context);
     }
-    registerChatWelcome(controller, context) {
+    registerSetupAgents(context, controller) {
+        const registration = markAsSingleton(( new MutableDisposable()));
+        const updateRegistration = () => {
+            const disabled = context.state.hidden || !this.configurationService.getValue('chat.setupFromDialog');
+            if (!disabled && !registration.value) {
+                const { agent: panelAgent, disposable: panelDisposable } = SetupChatAgentImplementation.register(this.instantiationService, ChatAgentLocation.Panel, false, context, controller);
+                registration.value = combinedDisposable(panelDisposable, SetupChatAgentImplementation.register(this.instantiationService, ChatAgentLocation.Terminal, false, context, controller).disposable, SetupChatAgentImplementation.register(this.instantiationService, ChatAgentLocation.Notebook, false, context, controller).disposable, SetupChatAgentImplementation.register(this.instantiationService, ChatAgentLocation.Editor, false, context, controller).disposable, SetupChatAgentImplementation.register(this.instantiationService, ChatAgentLocation.EditingSession, false, context, controller).disposable, SetupChatAgentImplementation.register(this.instantiationService, ChatAgentLocation.EditingSession, true, context, controller).disposable, panelAgent.onUnresolvableError(() => {
+                    this.logService.error('[chat setup] Unresolvable error from Copilot agent registration, clearing registration.');
+                    panelDisposable.dispose();
+                }));
+            }
+            else if (disabled && registration.value) {
+                registration.clear();
+            }
+        };
+        this._register(Event.runAndSubscribe(Event.any(context.onDidChange, Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('chat.setupFromDialog'))), () => updateRegistration()));
+    }
+    registerChatWelcome(context, controller) {
         ( Registry.as(ChatViewsWelcomeExtensions.ChatViewsWelcomeRegistry)).register({
-            title: ( localize(4686, "Welcome to Copilot")),
+            title: ( localize(4812, "Welcome to Copilot")),
             when: ChatContextKeys.SetupViewCondition,
             icon: Codicon.copilotLarge,
             content: disposables => disposables.add(this.instantiationService.createInstance(ChatSetupWelcomeContent, controller.value, context)).element,
         });
     }
-    registerActions(context, requests) {
-        const chatSetupTriggerContext = ( ContextKeyExpr.or(( ChatContextKeys.Setup.installed.negate()), ChatContextKeys.Setup.canSignUp));
+    registerActions(context, requests, controller) {
+        const chatSetupTriggerContext = ( ContextKeyExpr.or(( ChatContextKeys.Setup.installed.negate()), ChatContextKeys.Entitlement.canSignUp));
+        const CHAT_SETUP_ACTION_LABEL = ( localize2(4813, "Use AI Features with Copilot for free..."));
         class ChatSetupTriggerAction extends Action2 {
             constructor() {
                 super({
@@ -165,33 +556,59 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
                         id: MenuId.ChatTitleBarMenu,
                         group: 'a_last',
                         order: 1,
-                        when: chatSetupTriggerContext
+                        when: ( ContextKeyExpr.and(chatSetupTriggerContext, ( ContextKeyExpr.or(( ChatContextKeys.Setup.fromDialog.negate()),
+                        ChatContextKeys.Setup.hidden))))
                     }
                 });
             }
-            async run(accessor) {
+            async run(accessor, mode) {
                 const viewsService = accessor.get(IViewsService);
                 const viewDescriptorService = accessor.get(IViewDescriptorService);
                 const configurationService = accessor.get(IConfigurationService);
                 const layoutService = accessor.get(IWorkbenchLayoutService);
                 const statusbarService = accessor.get(IStatusbarService);
+                const instantiationService = accessor.get(IInstantiationService);
+                const dialogService = accessor.get(IDialogService);
+                const commandService = accessor.get(ICommandService);
+                const lifecycleService = accessor.get(ILifecycleService);
                 await context.update({ hidden: false });
-                showCopilotView(viewsService, layoutService);
-                ensureSideBarChatViewSize(viewDescriptorService, layoutService, viewsService);
+                const chatWidgetPromise = showCopilotView(viewsService, layoutService);
+                if (mode) {
+                    const chatWidget = await chatWidgetPromise;
+                    chatWidget?.input.setChatMode(mode);
+                }
+                const setupFromDialog = configurationService.getValue('chat.setupFromDialog');
+                if (!setupFromDialog) {
+                    ensureSideBarChatViewSize(viewDescriptorService, layoutService, viewsService);
+                }
                 statusbarService.updateEntryVisibility('chat.statusBarEntry', true);
                 configurationService.updateValue('chat.commandCenter.enabled', true);
+                if (setupFromDialog) {
+                    const setup = ChatSetup.getInstance(instantiationService, context, controller);
+                    const result = await setup.run();
+                    if (result === false && !lifecycleService.willShutdown) {
+                        const { confirmed } = await dialogService.confirm({
+                            type: Severity.Error,
+                            message: ( localize(4814, "Copilot setup failed. Would you like to try again?")),
+                            primaryButton: ( localize(4815, "Retry")),
+                        });
+                        if (confirmed) {
+                            commandService.executeCommand(CHAT_SETUP_ACTION_ID);
+                        }
+                    }
+                }
             }
         }
         class ChatSetupHideAction extends Action2 {
             static { this.ID = 'workbench.action.chat.hideSetup'; }
-            static { this.TITLE = ( localize2(4687, "Hide Copilot")); }
+            static { this.TITLE = ( localize2(4816, "Hide Copilot")); }
             constructor() {
                 super({
                     id: ChatSetupHideAction.ID,
                     title: ChatSetupHideAction.TITLE,
                     f1: true,
                     category: CHAT_CATEGORY,
-                    precondition: ( ChatContextKeys.Setup.installed.negate()),
+                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.installed.negate()), ( ChatContextKeys.Setup.hidden.negate()))),
                     menu: {
                         id: MenuId.ChatTitleBarMenu,
                         group: 'z_hide',
@@ -207,13 +624,13 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
                 const dialogService = accessor.get(IDialogService);
                 const statusbarService = accessor.get(IStatusbarService);
                 const { confirmed } = await dialogService.confirm({
-                    message: ( localize(4688, "Are you sure you want to hide Copilot?")),
+                    message: ( localize(4817, "Are you sure you want to hide Copilot?")),
                     detail: ( localize(
-                        4689,
+                        4818,
                         "You can restore Copilot by running the '{0}' command.",
                         CHAT_SETUP_ACTION_LABEL.value
                     )),
-                    primaryButton: ( localize(4690, "Hide Copilot"))
+                    primaryButton: ( localize(4819, "Hide Copilot"))
                 });
                 if (!confirmed) {
                     return;
@@ -235,10 +652,10 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
             constructor() {
                 super({
                     id: 'workbench.action.chat.upgradePlan',
-                    title: ( localize2(4691, "Upgrade to Copilot Pro")),
-                    category: ( localize2(4692, 'Chat')),
+                    title: ( localize2(4820, "Upgrade to Copilot Pro")),
+                    category: ( localize2(4821, 'Chat')),
                     f1: true,
-                    precondition: ( ContextKeyExpr.or(ChatContextKeys.Setup.canSignUp, ChatContextKeys.Setup.limited)),
+                    precondition: ( ContextKeyExpr.or(ChatContextKeys.Entitlement.canSignUp, ChatContextKeys.Entitlement.limited)),
                     menu: {
                         id: MenuId.ChatTitleBarMenu,
                         group: 'a_first',
@@ -250,12 +667,10 @@ let ChatSetupContribution = class ChatSetupContribution extends Disposable {
                     }
                 });
             }
-            async run(accessor) {
+            async run(accessor, from) {
                 const openerService = accessor.get(IOpenerService);
-                const telemetryService = accessor.get(ITelemetryService);
                 const hostService = accessor.get(IHostService);
                 const commandService = accessor.get(ICommandService);
-                telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: 'chat' });
                 openerService.open(( URI.parse(defaultChat.upgradePlanUrl)));
                 const entitlement = context.state.entitlement;
                 if (entitlement !== ChatEntitlement.Pro) {
@@ -284,368 +699,21 @@ 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);
+                await this.commandService.executeCommand(CHAT_SETUP_ACTION_ID, validateChatMode(params.get('mode')));
                 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(4693, "Chat")),
-                    type: 'object',
-                    properties: {
-                        'chat.agent.maxRequests': {
-                            type: 'number',
-                            markdownDescription: ( localize(
-                                4694,
-                                "The maximum number of requests to allow Copilot Edits to use per-turn in agent mode. When the limit is reached, Copilot will ask the user to confirm that it should keep working. \n\n> **Note**: For users on the Copilot Free plan, note that each agent mode request currently uses one chat request."
-                            )),
-                            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, ICommandService)),
     ( __param(3, ITelemetryService)),
-    ( __param(4, IWorkbenchAssignmentService)),
-    ( __param(5, IChatEntitlementsService))
+    ( __param(4, IChatEntitlementService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ILogService))
 ], 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;
-        this.telemetryService = telemetryService;
-        this.authenticationService = authenticationService;
-        this.logService = logService;
-        this.requestService = requestService;
-        this.chatQuotasService = chatQuotasService;
-        this.dialogService = dialogService;
-        this.openerService = openerService;
-        this.configurationService = configurationService;
-        this.state = { entitlement: this.context.state.entitlement };
-        this.pendingResolveCts = ( new CancellationTokenSource());
-        this.didResolveEntitlements = false;
-        this.registerListeners();
-        this.resolve();
-    }
-    registerListeners() {
-        this._register(this.authenticationService.onDidChangeDeclaredProviders(() => this.resolve()));
-        this._register(this.authenticationService.onDidChangeSessions(e => {
-            if (e.providerId === ChatSetupRequests_1.providerId(this.configurationService)) {
-                this.resolve();
-            }
-        }));
-        this._register(this.authenticationService.onDidRegisterAuthenticationProvider(e => {
-            if (e.id === ChatSetupRequests_1.providerId(this.configurationService)) {
-                this.resolve();
-            }
-        }));
-        this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(e => {
-            if (e.id === ChatSetupRequests_1.providerId(this.configurationService)) {
-                this.resolve();
-            }
-        }));
-        this._register(this.context.onDidChange(() => {
-            if (!this.context.state.installed || this.context.state.entitlement === ChatEntitlement.Unknown) {
-                this.state = { entitlement: this.state.entitlement, quotas: undefined };
-                this.chatQuotasService.clearQuotas();
-            }
-        }));
-    }
-    async resolve() {
-        this.pendingResolveCts.dispose(true);
-        const cts = this.pendingResolveCts = ( new CancellationTokenSource());
-        const session = await this.findMatchingProviderSession(cts.token);
-        if (cts.token.isCancellationRequested) {
-            return;
-        }
-        let state = undefined;
-        if (session) {
-            if (this.state.entitlement === ChatEntitlement.Unknown) {
-                state = { entitlement: ChatEntitlement.Unresolved };
-            }
-        }
-        else {
-            this.didResolveEntitlements = false;
-            state = { entitlement: ChatEntitlement.Unknown };
-        }
-        if (state) {
-            this.update(state);
-        }
-        if (session && !this.didResolveEntitlements) {
-            await this.resolveEntitlement(session, cts.token);
-        }
-    }
-    async findMatchingProviderSession(token) {
-        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) {
-                if (this.scopesMatch(session.scopes, scopes)) {
-                    return session;
-                }
-            }
-        }
-        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));
-    }
-    async resolveEntitlement(session, token) {
-        const entitlements = await this.doResolveEntitlement(session, token);
-        if (typeof entitlements?.entitlement === 'number' && !token.isCancellationRequested) {
-            this.didResolveEntitlements = true;
-            this.update(entitlements);
-        }
-        return entitlements;
-    }
-    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;
-        }
-        const response = await this.request(defaultChat.entitlementUrl, 'GET', undefined, session, token);
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        if (!response) {
-            this.logService.trace('[chat setup] entitlement: no response');
-            return { entitlement: ChatEntitlement.Unresolved };
-        }
-        if (response.res.statusCode && response.res.statusCode !== 200) {
-            this.logService.trace(`[chat setup] entitlement: unexpected status code ${response.res.statusCode}`);
-            return { entitlement: ChatEntitlement.Unresolved };
-        }
-        let responseText = null;
-        try {
-            responseText = await asText(response);
-        }
-        catch (error) {
-        }
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        if (!responseText) {
-            this.logService.trace('[chat setup] entitlement: response has no content');
-            return { entitlement: ChatEntitlement.Unresolved };
-        }
-        let entitlementsResponse;
-        try {
-            entitlementsResponse = JSON.parse(responseText);
-            this.logService.trace(`[chat setup] entitlement: parsed result is ${JSON.stringify(entitlementsResponse)}`);
-        }
-        catch (err) {
-            this.logService.trace(`[chat setup] entitlement: error parsing response (${err})`);
-            return { entitlement: ChatEntitlement.Unresolved };
-        }
-        let entitlement;
-        if (entitlementsResponse.access_type_sku === 'free_limited_copilot') {
-            entitlement = ChatEntitlement.Limited;
-        }
-        else if (entitlementsResponse.can_signup_for_limited) {
-            entitlement = ChatEntitlement.Available;
-        }
-        else if (entitlementsResponse.chat_enabled) {
-            entitlement = ChatEntitlement.Pro;
-        }
-        else {
-            entitlement = ChatEntitlement.Unavailable;
-        }
-        const entitlements = {
-            entitlement,
-            quotas: {
-                chatTotal: entitlementsResponse.monthly_quotas?.chat,
-                completionsTotal: entitlementsResponse.monthly_quotas?.completions,
-                chatRemaining: entitlementsResponse.limited_user_quotas?.chat,
-                completionsRemaining: entitlementsResponse.limited_user_quotas?.completions,
-                resetDate: entitlementsResponse.limited_user_reset_date
-            }
-        };
-        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,
-            quotaResetDate: entitlementsResponse.limited_user_reset_date
-        });
-        return entitlements;
-    }
-    async request(url, type, body, session, token) {
-        try {
-            return await this.requestService.request({
-                type,
-                url,
-                data: type === 'POST' ? JSON.stringify(body) : undefined,
-                disableCache: true,
-                headers: {
-                    'Authorization': `Bearer ${session.accessToken}`
-                }
-            }, token);
-        }
-        catch (error) {
-            this.logService.error(`[chat setup] request: error ${error}`);
-            return undefined;
-        }
-    }
-    update(state) {
-        this.state = state;
-        this.context.update({ entitlement: this.state.entitlement });
-        if (state.quotas) {
-            this.chatQuotasService.acceptQuotas({
-                chatQuotaExceeded: typeof state.quotas.chatRemaining === 'number' ? state.quotas.chatRemaining <= 0 : false,
-                completionsQuotaExceeded: typeof state.quotas.completionsRemaining === 'number' ? state.quotas.completionsRemaining <= 0 : false,
-                quotaResetDate: state.quotas.resetDate ? ( new Date(state.quotas.resetDate)) : undefined,
-                chatTotal: state.quotas.chatTotal,
-                completionsTotal: state.quotas.completionsTotal,
-                chatRemaining: state.quotas.chatRemaining,
-                completionsRemaining: state.quotas.completionsRemaining
-            });
-        }
-    }
-    async forceResolveEntitlement(session, token = CancellationToken.None) {
-        if (!session) {
-            session = await this.findMatchingProviderSession(token);
-        }
-        if (!session) {
-            return undefined;
-        }
-        return this.resolveEntitlement(session, token);
-    }
-    async signUpLimited(session) {
-        const body = {
-            restricted_telemetry: this.telemetryService.telemetryLevel === TelemetryLevel.NONE ? 'disabled' : 'enabled',
-            public_code_suggestions: 'enabled'
-        };
-        const response = await this.request(defaultChat.entitlementSignupLimitedUrl, 'POST', body, session, CancellationToken.None);
-        if (!response) {
-            const retry = await this.onUnknownSignUpError(( localize(4695, "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) {
-                try {
-                    const responseText = await asText(response);
-                    if (responseText) {
-                        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 { errorCode: response.res.statusCode };
-                        }
-                    }
-                }
-                catch (error) {
-                }
-            }
-            const retry = await this.onUnknownSignUpError(( localize(4696, "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 {
-            responseText = await asText(response);
-        }
-        catch (error) {
-        }
-        if (!responseText) {
-            const retry = await this.onUnknownSignUpError(( localize(4697, "Response has no contents.")), '[chat setup] sign-up: response has no content');
-            return retry ? this.signUpLimited(session) : { errorCode: 2 };
-        }
-        let parsedResult = undefined;
-        try {
-            parsedResult = JSON.parse(responseText);
-            this.logService.trace(`[chat setup] sign-up: response is ${responseText}`);
-        }
-        catch (err) {
-            const retry = await this.onUnknownSignUpError(( localize(4698, "Invalid response contents.")), `[chat setup] sign-up: error parsing response (${err})`);
-            return retry ? this.signUpLimited(session) : { errorCode: 3 };
-        }
-        this.update({ entitlement: ChatEntitlement.Limited });
-        return Boolean(parsedResult?.subscribed);
-    }
-    async onUnknownSignUpError(detail, logMessage) {
-        this.logService.error(logMessage);
-        const { confirmed } = await this.dialogService.confirm({
-            type: Severity.Error,
-            message: ( localize(
-                4699,
-                "An error occurred while signing up for Copilot Free. Would you like to try again?"
-            )),
-            detail,
-            primaryButton: ( localize(4700, "Retry"))
-        });
-        return confirmed;
-    }
-    onUnprocessableSignUpError(logMessage, logDetails) {
-        this.logService.error(logMessage);
-        this.dialogService.prompt({
-            type: Severity.Error,
-            message: ( localize(4701, "An error occurred while signing up for Copilot Free.")),
-            detail: logDetails,
-            buttons: [
-                {
-                    label: ( localize(4702, "OK")),
-                    run: () => { }
-                },
-                {
-                    label: ( localize(4703, "Learn More")),
-                    run: () => this.openerService.open(( URI.parse(defaultChat.upgradePlanUrl)))
-                }
-            ]
-        });
-    }
-    dispose() {
-        this.pendingResolveCts.dispose(true);
-        super.dispose();
-    }
-};
-ChatSetupRequests = ChatSetupRequests_1 = ( __decorate([
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IAuthenticationService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IRequestService)),
-    ( __param(5, IChatQuotasService)),
-    ( __param(6, IDialogService)),
-    ( __param(7, IOpenerService)),
-    ( __param(8, IConfigurationService))
-], ChatSetupRequests));
 var ChatSetupStep;
 (function (ChatSetupStep) {
     ChatSetupStep[ChatSetupStep["Initial"] = 1] = "Initial";
@@ -654,13 +722,12 @@ var ChatSetupStep;
 })(ChatSetupStep || (ChatSetupStep = {}));
 let ChatSetupController = class ChatSetupController extends Disposable {
     get step() { return this._step; }
-    constructor(context, requests, telemetryService, authenticationService, authenticationExtensionsService, viewsService, extensionsWorkbenchService, productService, logService, progressService, chatAgentService, activityService, commandService, layoutService, workspaceTrustRequestService, dialogService, configurationService, lifecycleService) {
+    constructor(context, requests, telemetryService, authenticationService, viewsService, extensionsWorkbenchService, productService, logService, progressService, chatAgentService, activityService, commandService, layoutService, workspaceTrustRequestService, dialogService, configurationService, lifecycleService, quickInputService) {
         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;
@@ -674,15 +741,14 @@ let ChatSetupController = class ChatSetupController extends Disposable {
         this.dialogService = dialogService;
         this.configurationService = configurationService;
         this.lifecycleService = lifecycleService;
+        this.quickInputService = quickInputService;
         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) {
@@ -693,48 +759,49 @@ let ChatSetupController = class ChatSetupController extends Disposable {
     }
     async setup(options) {
         const watch = ( new StopWatch(false));
-        const title = ( localize(4704, "Getting Copilot ready..."));
+        const title = ( localize(4822, "Getting Copilot ready..."));
         const badge = this.activityService.showViewContainerActivity(preferCopilotEditsView(this.viewsService) ? CHAT_EDITING_SIDEBAR_PANEL_ID : CHAT_SIDEBAR_PANEL_ID, {
             badge: ( new ProgressBadge(() => title)),
         });
         try {
-            await this.progressService.withProgress({
+            return await this.progressService.withProgress({
                 location: ProgressLocation.Window,
-                command: CHAT_SETUP_ACTION_ID,
+                command: CHAT_OPEN_ACTION_ID,
                 title,
-            }, () => this.doSetup(options?.forceSignIn ?? false, watch));
+            }, () => this.doSetup(options ?? {}, watch));
         }
         finally {
             badge.dispose();
         }
     }
-    async doSetup(forceSignIn, watch) {
+    async doSetup(options, watch) {
         this.context.suspend();
         let focusChatInput = false;
+        let success = false;
         try {
-            const providerId = ChatSetupRequests.providerId(this.configurationService);
+            const providerId = ChatEntitlementRequests.providerId(this.configurationService);
             let session;
             let entitlement;
-            if (this.context.state.entitlement === ChatEntitlement.Unknown || forceSignIn) {
+            if (this.context.state.entitlement === ChatEntitlement.Unknown || options.forceSignIn) {
                 this.setStep(ChatSetupStep.SigningIn);
-                const result = await this.signIn(providerId);
+                const result = await this.signIn(providerId, options);
                 if (!result.session) {
-                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotSignedIn', installDuration: watch.elapsed(), signUpErrorCode: undefined });
-                    return;
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotSignedIn', installDuration: watch.elapsed(), signUpErrorCode: undefined, setupFromDialog: Boolean(options.setupFromDialog) });
+                    return false;
                 }
                 session = result.session;
                 entitlement = result.entitlement;
             }
             const trusted = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-                message: ( localize(4705, "Copilot is currently only supported in trusted workspaces."))
+                message: ( localize(4823, "Copilot is currently only supported in trusted workspaces."))
             });
             if (!trusted) {
-                this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotTrusted', installDuration: watch.elapsed(), signUpErrorCode: undefined });
-                return;
+                this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotTrusted', installDuration: watch.elapsed(), signUpErrorCode: undefined, setupFromDialog: Boolean(options.setupFromDialog) });
+                return false;
             }
             const activeElement = getActiveElement();
             this.setStep(ChatSetupStep.Installing);
-            await this.install(session, entitlement ?? this.context.state.entitlement, providerId, watch);
+            success = await this.install(session, entitlement ?? this.context.state.entitlement, providerId, options, watch);
             const currentActiveElement = getActiveElement();
             focusChatInput = activeElement === currentActiveElement || currentActiveElement === mainWindow.document.body;
         }
@@ -742,45 +809,47 @@ let ChatSetupController = class ChatSetupController extends Disposable {
             this.setStep(ChatSetupStep.Initial);
             this.context.resume();
         }
-        if (focusChatInput) {
+        if (focusChatInput && !options.setupFromDialog) {
             (await showCopilotView(this.viewsService, this.layoutService))?.focusInput();
         }
+        return success;
     }
-    async signIn(providerId) {
+    async signIn(providerId, options) {
         let session;
         let entitlements;
         try {
-            showCopilotView(this.viewsService, this.layoutService);
-            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);
-            entitlements = await this.requests.forceResolveEntitlement(session);
+            if (!options?.setupFromDialog) {
+                showCopilotView(this.viewsService, this.layoutService);
+            }
+            ({ session, entitlements } = await this.requests.signIn());
         }
         catch (e) {
             this.logService.error(`[chat setup] signIn: error ${e}`);
         }
-        if (!session && !this.willShutdown) {
+        if (!session && !this.lifecycleService.willShutdown) {
             const { confirmed } = await this.dialogService.confirm({
                 type: Severity.Error,
                 message: ( localize(
-                    4706,
+                    4824,
                     "Failed to sign in to {0}. Would you like to try again?",
-                    ChatSetupRequests.providerId(this.configurationService) === defaultChat.enterpriseProviderId ? defaultChat.enterpriseProviderName : defaultChat.providerName
+                    ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.enterpriseProviderId ? defaultChat.enterpriseProviderName : defaultChat.providerName
                 )),
-                detail: ( localize(4707, "You must be signed in to use Copilot.")),
-                primaryButton: ( localize(4700, "Retry"))
+                detail: ( localize(4825, "You must be signed in to use Copilot.")),
+                primaryButton: ( localize(4815, "Retry"))
             });
             if (confirmed) {
-                return this.signIn(providerId);
+                return this.signIn(providerId, options);
             }
         }
         return { session, entitlement: entitlements?.entitlement };
     }
-    async install(session, entitlement, providerId, watch) {
+    async install(session, entitlement, providerId, options, watch) {
         const wasInstalled = this.context.state.installed;
         let signUpResult = undefined;
         try {
-            showCopilotView(this.viewsService, this.layoutService);
+            if (!options?.setupFromDialog) {
+                showCopilotView(this.viewsService, this.layoutService);
+            }
             if (entitlement !== ChatEntitlement.Limited &&
                 entitlement !== ChatEntitlement.Pro &&
                 entitlement !== ChatEntitlement.Unavailable
@@ -792,30 +861,33 @@ let ChatSetupController = class ChatSetupController extends Disposable {
                     catch (error) {
                     }
                     if (!session) {
-                        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNoSession', installDuration: watch.elapsed(), signUpErrorCode: undefined });
-                        return;
+                        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNoSession', installDuration: watch.elapsed(), signUpErrorCode: undefined, setupFromDialog: Boolean(options.setupFromDialog) });
+                        return false;
                     }
                 }
                 signUpResult = await this.requests.signUpLimited(session);
                 if (typeof signUpResult !== 'boolean' ) {
-                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedSignUp', installDuration: watch.elapsed(), signUpErrorCode: signUpResult.errorCode });
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedSignUp', installDuration: watch.elapsed(), signUpErrorCode: signUpResult.errorCode, setupFromDialog: Boolean(options.setupFromDialog) });
                 }
             }
             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: isCancellationError(error) ? 'cancelled' : 'failedInstall', installDuration: watch.elapsed(), signUpErrorCode: undefined, setupFromDialog: Boolean(options.setupFromDialog) });
+            return false;
         }
-        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'installed', installDuration: watch.elapsed(), signUpErrorCode: undefined });
+        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: wasInstalled ? 'alreadyInstalled' : 'installed', installDuration: watch.elapsed(), signUpErrorCode: undefined, setupFromDialog: Boolean(options.setupFromDialog) });
         if (wasInstalled && signUpResult === true) {
             refreshTokens(this.commandService);
         }
-        await Promise.race([
-            timeout(5000),
-            Event.toPromise(this.chatAgentService.onDidChangeAgents)
-        ]);
+        if (!options?.setupFromDialog) {
+            await Promise.race([
+                timeout(5000),
+                Event.toPromise(this.chatAgentService.onDidChangeAgents)
+            ]);
+        }
+        return true;
     }
     async doInstall() {
         let error;
@@ -833,15 +905,15 @@ let ChatSetupController = class ChatSetupController extends Disposable {
             error = e;
         }
         if (error) {
-            if (!this.willShutdown) {
+            if (!this.lifecycleService.willShutdown) {
                 const { confirmed } = await this.dialogService.confirm({
                     type: Severity.Error,
                     message: ( localize(
-                        4708,
+                        4826,
                         "An error occurred while setting up Copilot. Would you like to try again?"
                     )),
                     detail: error && !isCancellationError(error) ? toErrorMessage(error) : undefined,
-                    primaryButton: ( localize(4700, "Retry"))
+                    primaryButton: ( localize(4815, "Retry"))
                 });
                 if (confirmed) {
                     return this.doInstall();
@@ -850,27 +922,138 @@ let ChatSetupController = class ChatSetupController extends Disposable {
             throw error;
         }
     }
+    async setupWithProvider(options) {
+        const registry = ( Registry.as(Extensions.Configuration));
+        registry.registerConfiguration({
+            'id': 'copilot.setup',
+            'type': 'object',
+            'properties': {
+                [defaultChat.completionsAdvancedSetting]: {
+                    'type': 'object',
+                    'properties': {
+                        'authProvider': {
+                            'type': 'string'
+                        }
+                    }
+                },
+                [defaultChat.providerUriSetting]: {
+                    'type': 'string'
+                }
+            }
+        });
+        if (options.useEnterpriseProvider) {
+            const success = await this.handleEnterpriseInstance();
+            if (!success) {
+                return false;
+            }
+        }
+        let existingAdvancedSetting = this.configurationService.inspect(defaultChat.completionsAdvancedSetting).user?.value;
+        if (!isObject(existingAdvancedSetting)) {
+            existingAdvancedSetting = {};
+        }
+        if (options.useEnterpriseProvider) {
+            await this.configurationService.updateValue(`${defaultChat.completionsAdvancedSetting}`, {
+                ...existingAdvancedSetting,
+                'authProvider': defaultChat.enterpriseProviderId
+            }, ConfigurationTarget.USER);
+        }
+        else {
+            await this.configurationService.updateValue(`${defaultChat.completionsAdvancedSetting}`, ( Object.keys(existingAdvancedSetting)).length > 0 ? {
+                ...existingAdvancedSetting,
+                'authProvider': undefined
+            } : undefined, ConfigurationTarget.USER);
+            await this.configurationService.updateValue(defaultChat.providerUriSetting, undefined, ConfigurationTarget.USER);
+        }
+        return this.setup({ ...options, forceSignIn: true });
+    }
+    async handleEnterpriseInstance() {
+        const domainRegEx = /^[a-zA-Z\-_]+$/;
+        const fullUriRegEx = /^(https:\/\/)?([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.ghe\.com\/?$/;
+        const uri = this.configurationService.getValue(defaultChat.providerUriSetting);
+        if (typeof uri === 'string' && fullUriRegEx.test(uri)) {
+            return true;
+        }
+        let isSingleWord = false;
+        const result = await this.quickInputService.input({
+            prompt: ( localize(4827, "What is your {0} instance?", defaultChat.enterpriseProviderName)),
+            placeHolder: ( localize(4828, 'i.e. "octocat" or "https://octocat.ghe.com"...')),
+            ignoreFocusLost: true,
+            value: uri,
+            validateInput: async (value) => {
+                isSingleWord = false;
+                if (!value) {
+                    return undefined;
+                }
+                if (domainRegEx.test(value)) {
+                    isSingleWord = true;
+                    return {
+                        content: ( localize(4829, "Will resolve to {0}", `https://${value}.ghe.com`)),
+                        severity: Severity.Info
+                    };
+                }
+                if (!fullUriRegEx.test(value)) {
+                    return {
+                        content: ( localize(
+                            4830,
+                            'You must 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(
+                    4831,
+                    "The provided {0} instance is invalid. Would you like to enter it again?",
+                    defaultChat.enterpriseProviderName
+                )),
+                primaryButton: ( localize(4815, "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;
+    }
 };
 ChatSetupController = ( __decorate([
     ( __param(2, ITelemetryService)),
     ( __param(3, IAuthenticationService)),
-    ( __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))
+    ( __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(13, IWorkspaceTrustRequestService)),
+    ( __param(14, IDialogService)),
+    ( __param(15, IConfigurationService)),
+    ( __param(16, ILifecycleService)),
+    ( __param(17, IQuickInputService))
 ], ChatSetupController));
 let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
-    constructor(controller, context, instantiationService, contextMenuService, configurationService, telemetryService, quickInputService, dialogService) {
+    constructor(controller, context, instantiationService, contextMenuService, configurationService, telemetryService) {
         super();
         this.controller = controller;
         this.context = context;
@@ -878,8 +1061,6 @@ let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
         this.contextMenuService = contextMenuService;
         this.configurationService = configurationService;
         this.telemetryService = telemetryService;
-        this.quickInputService = quickInputService;
-        this.dialogService = dialogService;
         this.element = $('.chat-setup-view');
         this.create();
     }
@@ -887,41 +1068,25 @@ let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
         const markdown = this.instantiationService.createInstance(MarkdownRenderer, {});
         {
             const header = ( localize(
-                4709,
+                4832,
                 "[Copilot]({0}) is your AI pair programmer.",
-                this.context.state.installed ? 'command:github.copilot.open.walkthrough' : defaultChat.documentationUrl
+                this.context.state.installed ? `command:${defaultChat.walkthroughCommand}` : defaultChat.documentationUrl
             ));
-            this.element.appendChild($('p')).appendChild(this._register(markdown.render(( new MarkdownString(header, { isTrusted: true })))).element);
-            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(4710, "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(4711, "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(4712, "Explore your codebase with Chat"));
+            this.element.appendChild($('p', undefined, this._register(markdown.render(( new MarkdownString(header, { isTrusted: true })))).element));
+            this.element.appendChild($('div.chat-features-container', undefined, $('div', undefined, $('div.chat-feature-container', undefined, renderIcon(Codicon.code), $('span', undefined, ( localize(4833, "Code faster with Completions")))), $('div.chat-feature-container', undefined, renderIcon(Codicon.editSession), $('span', undefined, ( localize(4834, "Build features with Copilot Edits")))), $('div.chat-feature-container', undefined, renderIcon(Codicon.commentDiscussion), $('span', undefined, ( localize(4835, "Explore your codebase with Chat")))))));
         }
         const free = ( localize(
-            4713,
+            4836,
             "$(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 freeContainer = this.element.appendChild($('p', undefined, this._register(markdown.render(( new MarkdownString(free, { isTrusted: true, supportThemeIcons: true })))).element));
         const buttonContainer = this.element.appendChild($('p'));
         buttonContainer.classList.add('button-container');
         const button = this._register(( new ButtonWithDropdown(buttonContainer, {
             actions: [
-                toAction({ id: 'chatSetup.setupWithProvider', label: ( localize(4714, "Sign in with a {0} Account", defaultChat.providerName)), run: () => this.setupWithProvider(false) }),
-                toAction({ id: 'chatSetup.setupWithEnterpriseProvider', label: ( localize(4715, "Sign in with a {0} Account", defaultChat.enterpriseProviderName)), run: () => this.setupWithProvider(true) })
+                toAction({ id: 'chatSetup.setupWithProvider', label: ( localize(4800, "Sign in with a {0} Account", defaultChat.providerName)), run: () => this.controller.setupWithProvider({ useEnterpriseProvider: false }) }),
+                toAction({ id: 'chatSetup.setupWithEnterpriseProvider', label: ( localize(4801, "Sign in with a {0} Account", defaultChat.enterpriseProviderName)), run: () => this.controller.setupWithProvider({ useEnterpriseProvider: true }) })
             ],
             addPrimaryActionToDropdown: false,
             contextMenuProvider: this.contextMenuService,
@@ -930,20 +1095,19 @@ let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
         })));
         this._register(button.onDidClick(() => this.controller.setup()));
         const terms = ( localize(
-            4716,
+            4810,
             "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);
+        this.element.appendChild($('p', undefined, this._register(markdown.render(( new MarkdownString(terms, { isTrusted: true })))).element));
         const settings = ( localize(
-            4717,
+            4811,
             "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
         ));
-        const settingsContainer = this.element.appendChild($('p'));
-        settingsContainer.appendChild(this._register(markdown.render(( new MarkdownString(settings, { isTrusted: true })))).element);
+        const settingsContainer = this.element.appendChild($('p', undefined, this._register(markdown.render(( new MarkdownString(settings, { isTrusted: true })))).element));
         this._register(Event.runAndSubscribe(this.controller.onDidChange, () => this.update(freeContainer, settingsContainer, button)));
     }
     update(freeContainer, settingsContainer, button) {
@@ -953,33 +1117,33 @@ let ChatSetupWelcomeContent = class ChatSetupWelcomeContent extends Disposable {
         switch (this.context.state.entitlement) {
             case ChatEntitlement.Unknown:
                 showFree = true;
-                buttonLabel = this.context.state.registered ? ( localize(4718, "Sign in to Use Copilot")) : ( localize(4719, "Sign in to Use Copilot for Free"));
+                buttonLabel = this.context.state.registered ? ( localize(4804, "Sign in to use Copilot")) : ( localize(4805, "Sign in to use Copilot for free"));
                 break;
             case ChatEntitlement.Unresolved:
                 showFree = true;
-                buttonLabel = this.context.state.registered ? ( localize(4720, "Use Copilot")) : ( localize(4721, "Use Copilot for Free"));
+                buttonLabel = this.context.state.registered ? ( localize(4837, "Use Copilot")) : ( localize(4838, "Use Copilot for free"));
                 break;
             case ChatEntitlement.Available:
             case ChatEntitlement.Limited:
                 showFree = true;
-                buttonLabel = ( localize(4721, "Use Copilot for Free"));
+                buttonLabel = ( localize(4838, "Use Copilot for free"));
                 break;
             case ChatEntitlement.Pro:
             case ChatEntitlement.Unavailable:
                 showFree = false;
-                buttonLabel = ( localize(4720, "Use Copilot"));
+                buttonLabel = ( localize(4837, "Use Copilot"));
                 break;
         }
         switch (this.controller.step) {
             case ChatSetupStep.SigningIn:
                 buttonLabel = ( localize(
-                    4722,
+                    4839,
                     "$(loading~spin) Signing in to {0}...",
-                    ChatSetupRequests.providerId(this.configurationService) === defaultChat.enterpriseProviderId ? defaultChat.enterpriseProviderName : defaultChat.providerName
+                    ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.enterpriseProviderId ? defaultChat.enterpriseProviderName : defaultChat.providerName
                 ));
                 break;
             case ChatSetupStep.Installing:
-                buttonLabel = ( localize(4723, "$(loading~spin) Getting Copilot Ready..."));
+                buttonLabel = ( localize(4840, "$(loading~spin) Getting Copilot Ready..."));
                 break;
         }
         setVisibility(showFree, freeContainer);
@@ -987,208 +1151,16 @@ 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) {
-            const success = await this.handleEnterpriseInstance();
-            if (!success) {
-                return;
-            }
-            await this.configurationService.updateValue(defaultChat.providerSetting, defaultChat.enterpriseProviderId, ConfigurationTarget.USER);
-        }
-        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 domainRegEx = /^[a-zA-Z\-_]+$/;
-        const fullUriRegEx = /^(https:\/\/)?([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.ghe\.com\/?$/;
-        const uri = this.configurationService.getValue(defaultChat.providerUriSetting);
-        if (typeof uri === 'string' && fullUriRegEx.test(uri)) {
-            return true;
-        }
-        let isSingleWord = false;
-        const result = await this.quickInputService.input({
-            prompt: ( localize(4724, "What is your {0} instance?", defaultChat.enterpriseProviderName)),
-            placeHolder: ( localize(4725, 'i.e. "octocat" or "https://octocat.ghe.com"...')),
-            value: uri,
-            validateInput: async (value) => {
-                isSingleWord = false;
-                if (!value) {
-                    return undefined;
-                }
-                if (domainRegEx.test(value)) {
-                    isSingleWord = true;
-                    return {
-                        content: ( localize(4726, "Will resolve to {0}", `https://${value}.ghe.com`)),
-                        severity: Severity.Info
-                    };
-                }
-                if (!fullUriRegEx.test(value)) {
-                    return {
-                        content: ( localize(
-                            4727,
-                            '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(
-                    4728,
-                    "The provided {0} instance is invalid. Would you like to enter it again?",
-                    defaultChat.enterpriseProviderName
-                )),
-                primaryButton: ( localize(4700, "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, IConfigurationService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, IQuickInputService)),
-    ( __param(7, IDialogService))
+    ( __param(5, ITelemetryService))
 ], ChatSetupWelcomeContent));
-let ChatSetupContext = class ChatSetupContext extends Disposable {
-    static { ChatSetupContext_1 = this; }
-    static { this.CHAT_SETUP_CONTEXT_STORAGE_KEY = 'chat.setupContext'; }
-    get state() {
-        return this.suspendedState ?? this._state;
-    }
-    constructor(contextKeyService, storageService, workspaceContextService, extensionEnablementService, logService, extensionsWorkbenchService) {
-        super();
-        this.contextKeyService = contextKeyService;
-        this.storageService = storageService;
-        this.workspaceContextService = workspaceContextService;
-        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.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;
-        this._onDidChange = this._register(( new Emitter()));
-        this.onDidChange = this._onDidChange.event;
-        this.updateBarrier = undefined;
-        this.checkExtensionInstallation();
-        this.updateContextSync();
-    }
-    async checkExtensionInstallation() {
-        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) });
-        }));
-    }
-    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.hidden = false;
-            }
-        }
-        if (typeof context.hidden === 'boolean') {
-            this._state.hidden = context.hidden;
-        }
-        if (typeof context.entitlement === 'number') {
-            this._state.entitlement = context.entitlement;
-            if (this._state.entitlement === ChatEntitlement.Limited || this._state.entitlement === ChatEntitlement.Pro) {
-                this._state.registered = true;
-            }
-            else if (this._state.entitlement === ChatEntitlement.Available) {
-                this._state.registered = false;
-            }
-        }
-        this.storageService.store(ChatSetupContext_1.CHAT_SETUP_CONTEXT_STORAGE_KEY, this._state, StorageScope.PROFILE, StorageTarget.MACHINE);
-        return this.updateContext();
-    }
-    async updateContext() {
-        await this.updateBarrier?.wait();
-        this.updateContextSync();
-    }
-    updateContextSync() {
-        this.logService.trace(`[chat setup] updateContext(): ${JSON.stringify(this._state)}`);
-        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.proContextKey.set(this._state.entitlement === ChatEntitlement.Pro);
-        this.hiddenContext.set(!!this._state.hidden);
-        this.installedContext.set(!!this._state.installed);
-        this._onDidChange.fire();
-    }
-    suspend() {
-        this.suspendedState = { ...this._state };
-        this.updateBarrier = ( new Barrier());
-    }
-    resume() {
-        this.suspendedState = undefined;
-        this.updateBarrier?.open();
-        this.updateBarrier = undefined;
-    }
-};
-ChatSetupContext = ChatSetupContext_1 = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IWorkbenchExtensionEnablementService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IExtensionsWorkbenchService))
-], ChatSetupContext));
 function refreshTokens(commandService) {
-    commandService.executeCommand('github.copilot.signIn');
-    commandService.executeCommand('github.copilot.refreshToken');
+    commandService.executeCommand(defaultChat.completionsRefreshTokenCommand);
+    commandService.executeCommand(defaultChat.chatRefreshTokenCommand);
 }
 
-export { ChatEntitlementsService, ChatSetupContribution };
+export { ChatSetupContribution };