@codingame/monaco-vscode-chat-service-override 23.3.0 → 24.1.0

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

@@ -1,1617 +0,0 @@
-
-import { registerCss } from '@codingame/monaco-vscode-api/css';
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import * as chatSetup from './media/chatSetup.css';
-import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { Dialog, DialogContentsAlignment } from '@codingame/monaco-vscode-f1bbc6d3-6129-583c-a2ba-c80b832993d2-common/vscode/vs/base/browser/ui/dialog/dialog';
-import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-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 { 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, DisposableStore, markAsSingleton, MutableDisposable } 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 { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
-import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
-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 { createWorkbenchDialogOptions } from '@codingame/monaco-vscode-f1bbc6d3-6129-583c-a2ba-c80b832993d2-common/vscode/vs/platform/dialogs/browser/dialog';
-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 { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
-import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
-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 { 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 { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
-import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
-import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
-import { ProgressBadge } from '@codingame/monaco-vscode-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-common/vscode/vs/workbench/services/activity/common/activity';
-import { IActivityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity.service';
-import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
-import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { EnablementState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
-import { IWorkbenchExtensionEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.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 { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
-import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
-import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
-import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
-import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
-import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
-import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.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 { ChatEntitlement, ChatEntitlementRequests, isProUser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
-import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
-import { ChatRequestModel } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModel';
-import { ChatMode } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModes';
-import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
-import { ChatRequestToolPart, ChatRequestAgentPart } from '@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
-import { CHAT_SETUP_ACTION_ID, CHAT_CATEGORY, CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID, CHAT_OPEN_ACTION_ID } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { showChatView, ChatViewId } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/chat';
-import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { CHAT_SIDEBAR_PANEL_ID } from './chatViewPane.js';
-import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
-import { chatViewsWelcomeRegistry } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
-import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-
-var SetupAgent_1, DefaultNewSymbolNamesProvider_1, ChatSetup_1, ChatTeardownContribution_1;
-registerCss(chatSetup);
-const defaultChat = {
-    extensionId: product.defaultChatAgent?.extensionId ?? '',
-    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
-    publicCodeMatchesUrl: product.defaultChatAgent?.publicCodeMatchesUrl ?? '',
-    manageOveragesUrl: product.defaultChatAgent?.manageOverageUrl ?? '',
-    upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',
-    provider: product.defaultChatAgent?.provider ?? { default: { id: '', name: '' }, enterprise: { id: '', name: '' }, apple: { id: '', name: '' }, google: { id: '', name: '' } },
-    providerUriSetting: product.defaultChatAgent?.providerUriSetting ?? '',
-    manageSettingsUrl: product.defaultChatAgent?.manageSettingsUrl ?? '',
-    completionsAdvancedSetting: product.defaultChatAgent?.completionsAdvancedSetting ?? '',
-    completionsRefreshTokenCommand: product.defaultChatAgent?.completionsRefreshTokenCommand ?? '',
-    chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? '',
-    termsStatementUrl: product.defaultChatAgent?.termsStatementUrl ?? '',
-    privacyStatementUrl: product.defaultChatAgent?.privacyStatementUrl ?? ''
-};
-var ChatSetupAnonymous;
-(function (ChatSetupAnonymous) {
-    ChatSetupAnonymous[ChatSetupAnonymous["Disabled"] = 0] = "Disabled";
-    ChatSetupAnonymous[ChatSetupAnonymous["EnabledWithDialog"] = 1] = "EnabledWithDialog";
-    ChatSetupAnonymous[ChatSetupAnonymous["EnabledWithoutDialog"] = 2] = "EnabledWithoutDialog";
-})(ChatSetupAnonymous || (ChatSetupAnonymous = {}));
-const ToolsAgentContextKey = ( ContextKeyExpr.and(( ContextKeyExpr.equals(`config.${ChatConfiguration.AgentEnabled}`, true)),
-ContextKeyExpr.not(`previewFeaturesDisabled`)));
-let SetupAgent = class SetupAgent extends Disposable {
-    static { SetupAgent_1 = this; }
-    static registerDefaultAgents(instantiationService, location, mode, context, controller) {
-        return instantiationService.invokeFunction(accessor => {
-            const chatAgentService = accessor.get(IChatAgentService);
-            let id;
-            let description = ChatMode.Ask.description.get();
-            switch (location) {
-                case ChatAgentLocation.Chat:
-                    if (mode === ChatModeKind.Ask) {
-                        id = 'setup.chat';
-                    }
-                    else if (mode === ChatModeKind.Edit) {
-                        id = 'setup.edits';
-                        description = ChatMode.Edit.description.get();
-                    }
-                    else {
-                        id = 'setup.agent';
-                        description = ChatMode.Agent.description.get();
-                    }
-                    break;
-                case ChatAgentLocation.Terminal:
-                    id = 'setup.terminal';
-                    break;
-                case ChatAgentLocation.EditorInline:
-                    id = 'setup.editor';
-                    break;
-                case ChatAgentLocation.Notebook:
-                    id = 'setup.notebook';
-                    break;
-            }
-            return SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, id, `${defaultChat.provider.default.name} Copilot` , true, description, location, mode, context, controller);
-        });
-    }
-    static registerBuiltInAgents(instantiationService, context, controller) {
-        return instantiationService.invokeFunction(accessor => {
-            const chatAgentService = accessor.get(IChatAgentService);
-            const disposables = ( new DisposableStore());
-            const { disposable: vscodeDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.vscode', 'vscode', false, ( localize2(5435, "Ask questions about VS Code")).value, ChatAgentLocation.Chat, undefined, context, controller);
-            disposables.add(vscodeDisposable);
-            const { disposable: workspaceDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.workspace', 'workspace', false, ( localize2(5436, "Ask about your workspace")).value, ChatAgentLocation.Chat, undefined, context, controller);
-            disposables.add(workspaceDisposable);
-            const { disposable: terminalDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.terminal.agent', 'terminal', false, ( localize2(5437, "Ask how to do something in the terminal")).value, ChatAgentLocation.Chat, undefined, context, controller);
-            disposables.add(terminalDisposable);
-            disposables.add(SetupTool.registerTool(instantiationService, {
-                id: 'setup_tools_createNewWorkspace',
-                source: ToolDataSource.Internal,
-                icon: Codicon.newFolder,
-                displayName: ( localize(5438, "New Workspace")),
-                modelDescription: ( localize(5439, "Scaffold a new workspace in VS Code")),
-                userDescription: ( localize(5439, "Scaffold a new workspace in VS Code")),
-                canBeReferencedInPrompt: true,
-                toolReferenceName: 'new',
-                when: ContextKeyExpr.true(),
-            }));
-            return disposables;
-        });
-    }
-    static doRegisterAgent(instantiationService, chatAgentService, id, name, isDefault, description, location, mode, context, controller) {
-        const disposables = ( new DisposableStore());
-        disposables.add(chatAgentService.registerAgent(id, {
-            id,
-            name,
-            isDefault,
-            isCore: true,
-            modes: mode ? [mode] : [ChatModeKind.Ask],
-            when: mode === ChatModeKind.Agent ? ToolsAgentContextKey?.serialize() : undefined,
-            slashCommands: [],
-            disambiguation: [],
-            locations: [location],
-            metadata: { helpTextPrefix: SetupAgent_1.SETUP_NEEDED_MESSAGE },
-            description,
-            extensionId: nullExtensionDescription.identifier,
-            extensionVersion: undefined,
-            extensionDisplayName: nullExtensionDescription.name,
-            extensionPublisherId: nullExtensionDescription.publisher
-        }));
-        const agent = disposables.add(instantiationService.createInstance(SetupAgent_1, context, controller, location));
-        disposables.add(chatAgentService.registerAgentImplementation(id, agent));
-        if (mode === ChatModeKind.Agent) {
-            chatAgentService.updateAgent(id, { themeIcon: Codicon.tools });
-        }
-        return { agent, disposable: disposables };
-    }
-    static { this.SETUP_NEEDED_MESSAGE = ( new MarkdownString(( localize(5440, "You need to set up GitHub Copilot and be signed in to use Chat.")))); }
-    static { this.TRUST_NEEDED_MESSAGE = ( new MarkdownString(( localize(5441, "You need to trust this workspace to use Chat.")))); }
-    constructor(context, controller, location, instantiationService, logService, configurationService, telemetryService, environmentService, workspaceTrustManagementService, chatEntitlementService) {
-        super();
-        this.context = context;
-        this.controller = controller;
-        this.location = location;
-        this.instantiationService = instantiationService;
-        this.logService = logService;
-        this.configurationService = configurationService;
-        this.telemetryService = telemetryService;
-        this.environmentService = environmentService;
-        this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.chatEntitlementService = chatEntitlementService;
-        this._onUnresolvableError = this._register(( new Emitter()));
-        this.onUnresolvableError = this._onUnresolvableError.event;
-        this.pendingForwardedRequests = ( new ResourceMap());
-    }
-    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);
-            const languageModelToolsService = accessor.get(ILanguageModelToolsService);
-            return this.doInvoke(request, part => progress([part]), chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
-        });
-    }
-    async doInvoke(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
-        if (!this.context.state.installed ||
-            this.context.state.disabled ||
-            this.context.state.untrusted ||
-            this.context.state.entitlement === ChatEntitlement.Available ||
-            ((
-        this.context.state.entitlement === ChatEntitlement.Unknown && !this.chatEntitlementService.anonymous)
-            )) {
-            return this.doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
-        }
-        return this.doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
-    }
-    async doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
-        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(5442, "Getting chat ready...")))),
-        });
-        await this.forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
-        return {};
-    }
-    async forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
-        try {
-            await this.doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
-        }
-        catch (error) {
-            progress({
-                kind: 'warning',
-                content: ( new MarkdownString(( localize(5443, "Failed to get a response. Please try again."))))
-            });
-        }
-    }
-    async doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
-        if (( this.pendingForwardedRequests.has(requestModel.session.sessionResource))) {
-            throw ( new Error('Request already in progress'));
-        }
-        const forwardRequest = this.doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
-        this.pendingForwardedRequests.set(requestModel.session.sessionResource, forwardRequest);
-        try {
-            await forwardRequest;
-        }
-        finally {
-            this.pendingForwardedRequests.delete(requestModel.session.sessionResource);
-        }
-    }
-    async doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
-        const widget = chatWidgetService.getWidgetBySessionResource(requestModel.session.sessionResource);
-        const modeInfo = widget?.input.currentModeInfo;
-        let agentReady = false;
-        let languageModelReady = false;
-        let toolsModelReady = false;
-        const whenAgentReady = this.whenAgentReady(chatAgentService, modeInfo?.kind)?.then(() => agentReady = true);
-        const whenLanguageModelReady = this.whenLanguageModelReady(languageModelsService, requestModel.modelId)?.then(() => languageModelReady = true);
-        const whenToolsModelReady = this.whenToolsModelReady(languageModelToolsService, requestModel)?.then(() => toolsModelReady = true);
-        if (whenLanguageModelReady instanceof Promise || whenAgentReady instanceof Promise || whenToolsModelReady instanceof Promise) {
-            const timeoutHandle = setTimeout(() => {
-                progress({
-                    kind: 'progressMessage',
-                    content: ( new MarkdownString(( localize(5444, "Chat is almost ready...")))),
-                });
-            }, 10000);
-            try {
-                const ready = await Promise.race([
-                    timeout(this.environmentService.remoteAuthority ? 60000  : 20000).then(() => 'timedout'),
-                    this.whenDefaultAgentFailed(chatService).then(() => 'error'),
-                    Promise.allSettled([whenLanguageModelReady, whenAgentReady, whenToolsModelReady])
-                ]);
-                if (ready === 'error' || ready === 'timedout') {
-                    let warningMessage;
-                    if (ready === 'timedout') {
-                        if (this.chatEntitlementService.anonymous) {
-                            warningMessage = ( localize(
-                                5445,
-                                "Chat took too long to get ready. Please ensure that the extension `{0}` is installed and enabled.",
-                                defaultChat.chatExtensionId
-                            ));
-                        }
-                        else {
-                            warningMessage = ( localize(
-                                5446,
-                                "Chat took too long to get ready. Please ensure you are signed in to {0} and that the extension `{1}` is installed and enabled.",
-                                defaultChat.provider.default.name,
-                                defaultChat.chatExtensionId
-                            ));
-                        }
-                    }
-                    else {
-                        if (this.chatEntitlementService.anonymous) {
-                            warningMessage = ( localize(
-                                5447,
-                                "Chat failed to get ready. Please ensure that the extension `{0}` is installed and enabled.",
-                                defaultChat.chatExtensionId
-                            ));
-                        }
-                        else {
-                            warningMessage = ( localize(
-                                5448,
-                                "Chat failed to get ready. Please ensure you are signed in to {0} and that the extension `{1}` is installed and enabled.",
-                                defaultChat.provider.default.name,
-                                defaultChat.chatExtensionId
-                            ));
-                        }
-                    }
-                    this.logService.warn(warningMessage, {
-                        agentReady: whenAgentReady ? agentReady : undefined,
-                        languageModelReady: whenLanguageModelReady ? languageModelReady : undefined,
-                        toolsModelReady: whenToolsModelReady ? toolsModelReady : undefined
-                    });
-                    progress({
-                        kind: 'warning',
-                        content: ( new MarkdownString(warningMessage))
-                    });
-                    this._onUnresolvableError.fire();
-                    return;
-                }
-            }
-            finally {
-                clearTimeout(timeoutHandle);
-            }
-        }
-        await chatService.resendRequest(requestModel, {
-            ...widget?.getModeRequestOptions(),
-            modeInfo,
-            userSelectedModelId: widget?.input.currentLanguageModel
-        });
-    }
-    whenLanguageModelReady(languageModelsService, modelId) {
-        const hasModelForRequest = () => {
-            if (modelId) {
-                return !!languageModelsService.lookupLanguageModel(modelId);
-            }
-            for (const id of languageModelsService.getLanguageModelIds()) {
-                const model = languageModelsService.lookupLanguageModel(id);
-                if (model?.isDefault) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        if (hasModelForRequest()) {
-            return;
-        }
-        return Event.toPromise(Event.filter(languageModelsService.onDidChangeLanguageModels, () => hasModelForRequest()));
-    }
-    whenToolsModelReady(languageModelToolsService, requestModel) {
-        const needsToolsModel = ( requestModel.message.parts.some(part => part instanceof ChatRequestToolPart));
-        if (!needsToolsModel) {
-            return;
-        }
-        for (const tool of languageModelToolsService.getTools()) {
-            if (tool.id.startsWith('copilot_')) {
-                return;
-            }
-        }
-        return Event.toPromise(Event.filter(languageModelToolsService.onDidChangeTools, () => {
-            for (const tool of languageModelToolsService.getTools()) {
-                if (tool.id.startsWith('copilot_')) {
-                    return true;
-                }
-            }
-            return false;
-        }));
-    }
-    whenAgentReady(chatAgentService, mode) {
-        const defaultAgent = chatAgentService.getDefaultAgent(this.location, mode);
-        if (defaultAgent && !defaultAgent.isCore) {
-            return;
-        }
-        return Event.toPromise(Event.filter(chatAgentService.onDidChangeAgents, () => {
-            const defaultAgent = chatAgentService.getDefaultAgent(this.location, mode);
-            return Boolean(defaultAgent && !defaultAgent.isCore);
-        }));
-    }
-    async whenDefaultAgentFailed(chatService) {
-        return ( new Promise(resolve => {
-            chatService.activateDefaultAgent(this.location).catch(() => resolve());
-        }));
-    }
-    async doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
-        this.telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'chat' });
-        const widget = chatWidgetService.getWidgetBySessionId(request.sessionId);
-        const requestModel = widget?.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(
-                            5449,
-                            "Signing in to {0}...",
-                            ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id ? defaultChat.provider.enterprise.name : defaultChat.provider.default.name
-                        )))),
-                    });
-                    break;
-                case ChatSetupStep.Installing:
-                    progress({
-                        kind: 'progressMessage',
-                        content: ( new MarkdownString(( localize(5450, "Getting chat ready...")))),
-                    });
-                    break;
-            }
-        }));
-        let result = undefined;
-        try {
-            result = await ChatSetup.getInstance(this.instantiationService, this.context, this.controller).run({
-                disableChatViewReveal: true,
-                forceAnonymous: this.chatEntitlementService.anonymous ? ChatSetupAnonymous.EnabledWithoutDialog : undefined
-            });
-        }
-        catch (error) {
-            this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
-        }
-        finally {
-            setupListener.dispose();
-        }
-        if (typeof result?.success === 'boolean') {
-            if (result.success) {
-                if (result.dialogSkipped) {
-                    widget?.clear();
-                }
-                else if (requestModel) {
-                    let newRequest = this.replaceAgentInRequestModel(requestModel, chatAgentService);
-                    newRequest = this.replaceToolInRequestModel(newRequest);
-                    await this.forwardRequestToChat(newRequest, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
-                }
-            }
-            else {
-                progress({
-                    kind: 'warning',
-                    content: ( new MarkdownString(( localize(5451, "Chat setup failed."))))
-                });
-            }
-        }
-        else {
-            progress({
-                kind: 'markdownContent',
-                content: this.workspaceTrustManagementService.isWorkspaceTrusted() ? SetupAgent_1.SETUP_NEEDED_MESSAGE : SetupAgent_1.TRUST_NEEDED_MESSAGE
-            });
-        }
-        return {};
-    }
-    replaceAgentInRequestModel(requestModel, chatAgentService) {
-        const agentPart = requestModel.message.parts.find((r) => r instanceof ChatRequestAgentPart);
-        if (!agentPart) {
-            return requestModel;
-        }
-        const agentId = agentPart.agent.id.replace(/setup\./, `${defaultChat.extensionId}.`.toLowerCase());
-        const githubAgent = chatAgentService.getAgent(agentId);
-        if (!githubAgent) {
-            return requestModel;
-        }
-        const newAgentPart = ( new ChatRequestAgentPart(agentPart.range, agentPart.editorRange, githubAgent));
-        return ( new ChatRequestModel({
-            session: requestModel.session,
-            message: {
-                parts: ( requestModel.message.parts.map(part => {
-                    if (part instanceof ChatRequestAgentPart) {
-                        return newAgentPart;
-                    }
-                    return part;
-                })),
-                text: requestModel.message.text
-            },
-            variableData: requestModel.variableData,
-            timestamp: Date.now(),
-            attempt: requestModel.attempt,
-            modeInfo: requestModel.modeInfo,
-            confirmation: requestModel.confirmation,
-            locationData: requestModel.locationData,
-            attachedContext: requestModel.attachedContext,
-            isCompleteAddedRequest: requestModel.isCompleteAddedRequest,
-        }));
-    }
-    replaceToolInRequestModel(requestModel) {
-        const toolPart = requestModel.message.parts.find((r) => r instanceof ChatRequestToolPart);
-        if (!toolPart) {
-            return requestModel;
-        }
-        const toolId = toolPart.toolId.replace(/setup.tools\./, `copilot_`.toLowerCase());
-        const newToolPart = ( new ChatRequestToolPart(
-            toolPart.range,
-            toolPart.editorRange,
-            toolPart.toolName,
-            toolId,
-            toolPart.displayName,
-            toolPart.icon
-        ));
-        const chatRequestToolEntry = {
-            id: toolId,
-            name: 'new',
-            range: toolPart.range,
-            kind: 'tool',
-            value: undefined
-        };
-        const variableData = {
-            variables: [chatRequestToolEntry]
-        };
-        return ( new ChatRequestModel({
-            session: requestModel.session,
-            message: {
-                parts: ( requestModel.message.parts.map(part => {
-                    if (part instanceof ChatRequestToolPart) {
-                        return newToolPart;
-                    }
-                    return part;
-                })),
-                text: requestModel.message.text
-            },
-            variableData: variableData,
-            timestamp: Date.now(),
-            attempt: requestModel.attempt,
-            modeInfo: requestModel.modeInfo,
-            confirmation: requestModel.confirmation,
-            locationData: requestModel.locationData,
-            attachedContext: [chatRequestToolEntry],
-            isCompleteAddedRequest: requestModel.isCompleteAddedRequest,
-        }));
-    }
-};
-SetupAgent = SetupAgent_1 = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, IWorkbenchEnvironmentService)),
-    ( __param(8, IWorkspaceTrustManagementService)),
-    ( __param(9, IChatEntitlementService))
-], SetupAgent));
-class SetupTool {
-    static registerTool(instantiationService, toolData) {
-        return instantiationService.invokeFunction(accessor => {
-            const toolService = accessor.get(ILanguageModelToolsService);
-            const disposables = ( new DisposableStore());
-            const tool = instantiationService.createInstance(SetupTool);
-            disposables.add(toolService.registerTool(toolData, tool));
-            return disposables;
-        });
-    }
-    async invoke(invocation, countTokens, progress, token) {
-        const result = {
-            content: [
-                {
-                    kind: 'text',
-                    value: ''
-                }
-            ]
-        };
-        return result;
-    }
-    async prepareToolInvocation(parameters, token) {
-        return undefined;
-    }
-}
-let DefaultNewSymbolNamesProvider = DefaultNewSymbolNamesProvider_1 = class DefaultNewSymbolNamesProvider {
-    static registerProvider(instantiationService, context, controller) {
-        return instantiationService.invokeFunction(accessor => {
-            const languageFeaturesService = accessor.get(ILanguageFeaturesService);
-            const disposables = ( new DisposableStore());
-            const provider = instantiationService.createInstance(DefaultNewSymbolNamesProvider_1, context, controller);
-            disposables.add(languageFeaturesService.newSymbolNamesProvider.register('*', provider));
-            return disposables;
-        });
-    }
-    constructor(context, controller, instantiationService, chatEntitlementService) {
-        this.context = context;
-        this.controller = controller;
-        this.instantiationService = instantiationService;
-        this.chatEntitlementService = chatEntitlementService;
-    }
-    async provideNewSymbolNames(model, range, triggerKind, token) {
-        await this.instantiationService.invokeFunction(accessor => {
-            return ChatSetup.getInstance(this.instantiationService, this.context, this.controller).run({
-                forceAnonymous: this.chatEntitlementService.anonymous ? ChatSetupAnonymous.EnabledWithDialog : undefined
-            });
-        });
-        return [];
-    }
-};
-DefaultNewSymbolNamesProvider = DefaultNewSymbolNamesProvider_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IChatEntitlementService))
-], DefaultNewSymbolNamesProvider));
-var ChatSetupStrategy;
-(function (ChatSetupStrategy) {
-    ChatSetupStrategy[ChatSetupStrategy["Canceled"] = 0] = "Canceled";
-    ChatSetupStrategy[ChatSetupStrategy["DefaultSetup"] = 1] = "DefaultSetup";
-    ChatSetupStrategy[ChatSetupStrategy["SetupWithoutEnterpriseProvider"] = 2] = "SetupWithoutEnterpriseProvider";
-    ChatSetupStrategy[ChatSetupStrategy["SetupWithEnterpriseProvider"] = 3] = "SetupWithEnterpriseProvider";
-    ChatSetupStrategy[ChatSetupStrategy["SetupWithGoogleProvider"] = 4] = "SetupWithGoogleProvider";
-    ChatSetupStrategy[ChatSetupStrategy["SetupWithAppleProvider"] = 5] = "SetupWithAppleProvider";
-})(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,
-                    accessor.get(ITelemetryService),
-                    accessor.get(IWorkbenchLayoutService),
-                    accessor.get(IKeybindingService),
-                    accessor.get(IChatEntitlementService),
-                    accessor.get(ILogService),
-                    accessor.get(IConfigurationService),
-                    accessor.get(IViewsService),
-                    accessor.get(IWorkspaceTrustRequestService),
-                    accessor.get(IMarkdownRendererService)
-                ));
-            });
-        }
-        return instance;
-    }
-    constructor(context, controller, telemetryService, layoutService, keybindingService, chatEntitlementService, logService, configurationService, viewsService, workspaceTrustRequestService, markdownRendererService) {
-        this.context = context;
-        this.controller = controller;
-        this.telemetryService = telemetryService;
-        this.layoutService = layoutService;
-        this.keybindingService = keybindingService;
-        this.chatEntitlementService = chatEntitlementService;
-        this.logService = logService;
-        this.configurationService = configurationService;
-        this.viewsService = viewsService;
-        this.workspaceTrustRequestService = workspaceTrustRequestService;
-        this.markdownRendererService = markdownRendererService;
-        this.pendingRun = undefined;
-        this.skipDialogOnce = false;
-    }
-    skipDialog() {
-        this.skipDialogOnce = true;
-    }
-    async run(options) {
-        if (this.pendingRun) {
-            return this.pendingRun;
-        }
-        this.pendingRun = this.doRun(options);
-        try {
-            return await this.pendingRun;
-        }
-        finally {
-            this.pendingRun = undefined;
-        }
-    }
-    async doRun(options) {
-        this.context.update({ later: false });
-        const dialogSkipped = this.skipDialogOnce;
-        this.skipDialogOnce = false;
-        const trusted = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localize(5452, "AI features are currently only supported in trusted workspaces."))
-        });
-        if (!trusted) {
-            this.context.update({ later: true });
-            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotTrusted', installDuration: 0, signUpErrorCode: undefined, provider: undefined });
-            return { dialogSkipped, success: undefined  };
-        }
-        let setupStrategy;
-        if (!options?.forceSignInDialog && (dialogSkipped || isProUser(this.chatEntitlementService.entitlement) || this.chatEntitlementService.entitlement === ChatEntitlement.Free)) {
-            setupStrategy = ChatSetupStrategy.DefaultSetup;
-        }
-        else if (options?.forceAnonymous === ChatSetupAnonymous.EnabledWithoutDialog) {
-            setupStrategy = ChatSetupStrategy.DefaultSetup;
-        }
-        else {
-            setupStrategy = await this.showDialog(options);
-        }
-        if (setupStrategy === ChatSetupStrategy.DefaultSetup && ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id) {
-            setupStrategy = ChatSetupStrategy.SetupWithEnterpriseProvider;
-        }
-        if (setupStrategy !== ChatSetupStrategy.Canceled && !options?.disableChatViewReveal) {
-            showChatView(this.viewsService, this.layoutService);
-        }
-        let success = undefined;
-        try {
-            switch (setupStrategy) {
-                case ChatSetupStrategy.SetupWithEnterpriseProvider:
-                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: true, useSocialProvider: undefined, additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
-                    break;
-                case ChatSetupStrategy.SetupWithoutEnterpriseProvider:
-                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: false, useSocialProvider: undefined, additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
-                    break;
-                case ChatSetupStrategy.SetupWithAppleProvider:
-                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: false, useSocialProvider: 'apple', additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
-                    break;
-                case ChatSetupStrategy.SetupWithGoogleProvider:
-                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: false, useSocialProvider: 'google', additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
-                    break;
-                case ChatSetupStrategy.DefaultSetup:
-                    success = await this.controller.value.setup({ ...options, forceAnonymous: options?.forceAnonymous });
-                    break;
-                case ChatSetupStrategy.Canceled:
-                    this.context.update({ later: true });
-                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedMaybeLater', installDuration: 0, signUpErrorCode: undefined, provider: undefined });
-                    break;
-            }
-        }
-        catch (error) {
-            this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
-            success = false;
-        }
-        return { success, dialogSkipped };
-    }
-    async showDialog(options) {
-        const disposables = ( new DisposableStore());
-        const buttons = this.getButtons(options);
-        const dialog = disposables.add(( new Dialog(
-            this.layoutService.activeContainer,
-            this.getDialogTitle(options),
-            ( buttons.map(button => button[0])),
-            createWorkbenchDialogOptions({
-                type: 'none',
-                extraClasses: ['chat-setup-dialog'],
-                detail: ' ',
-                icon: Codicon.copilotLarge,
-                alignment: DialogContentsAlignment.Vertical,
-                cancelId: buttons.length - 1,
-                disableCloseButton: true,
-                renderFooter: footer => footer.appendChild(this.createDialogFooter(disposables, options)),
-                buttonOptions: ( buttons.map(button => button[2]))
-            }, this.keybindingService, this.layoutService)
-        )));
-        const { button } = await dialog.show();
-        disposables.dispose();
-        return buttons[button]?.[1] ?? ChatSetupStrategy.Canceled;
-    }
-    getButtons(options) {
-        const styleButton = (...classes) => ({ styleButton: (button) => button.element.classList.add(...classes) });
-        let buttons;
-        if (!options?.forceAnonymous && (this.context.state.entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog)) {
-            const defaultProviderButton = [( localize(5453, "Continue with {0}", defaultChat.provider.default.name)), ChatSetupStrategy.SetupWithoutEnterpriseProvider, styleButton('continue-button', 'default')];
-            const defaultProviderLink = [defaultProviderButton[0], defaultProviderButton[1], styleButton('link-button')];
-            const enterpriseProviderButton = [( localize(5453, "Continue with {0}", defaultChat.provider.enterprise.name)), ChatSetupStrategy.SetupWithEnterpriseProvider, styleButton('continue-button', 'default')];
-            const enterpriseProviderLink = [enterpriseProviderButton[0], enterpriseProviderButton[1], styleButton('link-button')];
-            const googleProviderButton = [( localize(5453, "Continue with {0}", defaultChat.provider.google.name)), ChatSetupStrategy.SetupWithGoogleProvider, styleButton('continue-button', 'google')];
-            const appleProviderButton = [( localize(5453, "Continue with {0}", defaultChat.provider.apple.name)), ChatSetupStrategy.SetupWithAppleProvider, styleButton('continue-button', 'apple')];
-            if (ChatEntitlementRequests.providerId(this.configurationService) !== defaultChat.provider.enterprise.id) {
-                buttons = coalesce([
-                    defaultProviderButton,
-                    googleProviderButton,
-                    appleProviderButton,
-                    enterpriseProviderLink
-                ]);
-            }
-            else {
-                buttons = coalesce([
-                    enterpriseProviderButton,
-                    googleProviderButton,
-                    appleProviderButton,
-                    defaultProviderLink
-                ]);
-            }
-        }
-        else {
-            buttons = [[( localize(5454, "Use AI Features")), ChatSetupStrategy.DefaultSetup, undefined]];
-        }
-        buttons.push([( localize(5455, "Skip for now")), ChatSetupStrategy.Canceled, styleButton('link-button', 'skip-button')]);
-        return buttons;
-    }
-    getDialogTitle(options) {
-        if (this.chatEntitlementService.anonymous) {
-            if (options?.forceAnonymous) {
-                return localize(5456, "Start using AI Features");
-            }
-            else {
-                return localize(5457, "Enable more AI features");
-            }
-        }
-        if (this.context.state.entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog) {
-            return localize(5458, "Sign in to use AI Features");
-        }
-        return localize(5456, "Start using AI Features");
-    }
-    createDialogFooter(disposables, options) {
-        const element = $('.chat-setup-dialog-footer');
-        let footer;
-        if (options?.forceAnonymous || this.telemetryService.telemetryLevel === TelemetryLevel.NONE) {
-            footer = ( localize(
-                5459,
-                "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}).",
-                defaultChat.provider.default.name,
-                defaultChat.termsStatementUrl,
-                defaultChat.privacyStatementUrl
-            ));
-        }
-        else {
-            footer = ( localize(
-                5460,
-                "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}). {3} Copilot may show [public code]({4}) suggestions and use your data to improve the product. You can change these [settings]({5}) anytime.",
-                defaultChat.provider.default.name,
-                defaultChat.termsStatementUrl,
-                defaultChat.privacyStatementUrl,
-                defaultChat.provider.default.name,
-                defaultChat.publicCodeMatchesUrl,
-                defaultChat.manageSettingsUrl
-            ));
-        }
-        element.appendChild($('p', undefined, disposables.add(this.markdownRendererService.render(( new MarkdownString(footer, { isTrusted: true })))).element));
-        return element;
-    }
-};
-ChatSetup = ChatSetup_1 = ( __decorate([
-    ( __param(2, ITelemetryService)),
-    ( __param(3, ILayoutService)),
-    ( __param(4, IKeybindingService)),
-    ( __param(5, IChatEntitlementService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IViewsService)),
-    ( __param(9, IWorkspaceTrustRequestService)),
-    ( __param(10, IMarkdownRendererService))
-], ChatSetup));
-let ChatSetupContribution = class ChatSetupContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.chatSetup'; }
-    constructor(productService, instantiationService, commandService, telemetryService, chatEntitlementService, chatModeService, logService, contextKeyService, extensionEnablementService, extensionsWorkbenchService, extensionService, environmentService, configurationService) {
-        super();
-        this.productService = productService;
-        this.instantiationService = instantiationService;
-        this.commandService = commandService;
-        this.telemetryService = telemetryService;
-        this.chatModeService = chatModeService;
-        this.logService = logService;
-        this.contextKeyService = contextKeyService;
-        this.extensionEnablementService = extensionEnablementService;
-        this.extensionsWorkbenchService = extensionsWorkbenchService;
-        this.extensionService = extensionService;
-        this.environmentService = environmentService;
-        this.configurationService = configurationService;
-        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.registerSetupAgents(context, controller);
-        this.registerActions(context, requests, controller);
-        this.registerUrlLinkHandler();
-        this.checkExtensionInstallation(context);
-    }
-    registerSetupAgents(context, controller) {
-        if (this.configurationService.getValue('chat.experimental.disableCoreAgents')) {
-            return;
-        }
-        const defaultAgentDisposables = markAsSingleton(( new MutableDisposable()));
-        const vscodeAgentDisposables = markAsSingleton(( new MutableDisposable()));
-        const renameProviderDisposables = markAsSingleton(( new MutableDisposable()));
-        const updateRegistration = () => {
-            {
-                if (!context.state.hidden && !context.state.disabled) {
-                    if (!defaultAgentDisposables.value) {
-                        const disposables = defaultAgentDisposables.value = ( new DisposableStore());
-                        const panelAgentDisposables = disposables.add(( new DisposableStore()));
-                        for (const mode of [ChatModeKind.Ask, ChatModeKind.Edit, ChatModeKind.Agent]) {
-                            const { agent, disposable } = SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Chat, mode, context, controller);
-                            panelAgentDisposables.add(disposable);
-                            panelAgentDisposables.add(agent.onUnresolvableError(() => {
-                                const panelAgentHasGuidance = ( chatViewsWelcomeRegistry.get().some(descriptor => this.contextKeyService.contextMatchesRules(descriptor.when)));
-                                if (panelAgentHasGuidance) {
-                                    this.logService.error('[chat setup] Unresolvable error from Chat agent registration, clearing registration.');
-                                    panelAgentDisposables.dispose();
-                                }
-                            }));
-                        }
-                        disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Terminal, undefined, context, controller).disposable);
-                        disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.Notebook, undefined, context, controller).disposable);
-                        disposables.add(SetupAgent.registerDefaultAgents(this.instantiationService, ChatAgentLocation.EditorInline, undefined, context, controller).disposable);
-                    }
-                    if ((!context.state.installed || context.state.entitlement === ChatEntitlement.Unknown || context.state.entitlement === ChatEntitlement.Unresolved) && !vscodeAgentDisposables.value) {
-                        const disposables = vscodeAgentDisposables.value = ( new DisposableStore());
-                        disposables.add(SetupAgent.registerBuiltInAgents(this.instantiationService, context, controller));
-                    }
-                }
-                else {
-                    defaultAgentDisposables.clear();
-                    vscodeAgentDisposables.clear();
-                }
-                if (context.state.installed && !context.state.disabled) {
-                    vscodeAgentDisposables.clear();
-                }
-            }
-            {
-                if (!context.state.installed && !context.state.hidden && !context.state.disabled) {
-                    if (!renameProviderDisposables.value) {
-                        renameProviderDisposables.value = DefaultNewSymbolNamesProvider.registerProvider(this.instantiationService, context, controller);
-                    }
-                }
-                else {
-                    renameProviderDisposables.clear();
-                }
-            }
-        };
-        this._register(Event.runAndSubscribe(context.onDidChange, () => updateRegistration()));
-    }
-    registerActions(context, requests, controller) {
-        class ChatSetupTriggerAction extends Action2 {
-            static { this.CHAT_SETUP_ACTION_LABEL = ( localize2(5461, "Use AI Features with Copilot for free...")); }
-            constructor() {
-                super({
-                    id: CHAT_SETUP_ACTION_ID,
-                    title: ChatSetupTriggerAction.CHAT_SETUP_ACTION_LABEL,
-                    category: CHAT_CATEGORY,
-                    f1: true,
-                    precondition: ( ContextKeyExpr.or(
-                        ChatContextKeys.Setup.hidden,
-                        ChatContextKeys.Setup.disabled,
-                        ChatContextKeys.Setup.untrusted,
-                        ( ChatContextKeys.Setup.installed.negate()),
-                        ChatContextKeys.Entitlement.canSignUp
-                    ))
-                });
-            }
-            async run(accessor, mode, options) {
-                const viewsService = accessor.get(IViewsService);
-                const layoutService = accessor.get(IWorkbenchLayoutService);
-                const instantiationService = accessor.get(IInstantiationService);
-                const dialogService = accessor.get(IDialogService);
-                const commandService = accessor.get(ICommandService);
-                const lifecycleService = accessor.get(ILifecycleService);
-                const configurationService = accessor.get(IConfigurationService);
-                await context.update({ hidden: false });
-                configurationService.updateValue(ChatTeardownContribution.CHAT_DISABLED_CONFIGURATION_KEY, false);
-                if (mode) {
-                    const chatWidget = await showChatView(viewsService, layoutService);
-                    chatWidget?.input.setChatMode(mode);
-                }
-                const setup = ChatSetup.getInstance(instantiationService, context, controller);
-                const { success } = await setup.run(options);
-                if (success === false && !lifecycleService.willShutdown) {
-                    const { confirmed } = await dialogService.confirm({
-                        type: Severity.Error,
-                        message: ( localize(5462, "Chat setup failed. Would you like to try again?")),
-                        primaryButton: ( localize(5463, "Retry")),
-                    });
-                    if (confirmed) {
-                        return Boolean(await commandService.executeCommand(CHAT_SETUP_ACTION_ID, mode, options));
-                    }
-                }
-                return Boolean(success);
-            }
-        }
-        class ChatSetupTriggerSupportAnonymousAction extends Action2 {
-            constructor() {
-                super({
-                    id: CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID,
-                    title: ChatSetupTriggerAction.CHAT_SETUP_ACTION_LABEL
-                });
-            }
-            async run(accessor) {
-                const commandService = accessor.get(ICommandService);
-                const telemetryService = accessor.get(ITelemetryService);
-                const chatEntitlementService = accessor.get(IChatEntitlementService);
-                telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'api' });
-                return commandService.executeCommand(CHAT_SETUP_ACTION_ID, undefined, {
-                    forceAnonymous: chatEntitlementService.anonymous ? ChatSetupAnonymous.EnabledWithDialog : undefined
-                });
-            }
-        }
-        class ChatSetupTriggerForceSignInDialogAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.action.chat.triggerSetupForceSignIn',
-                    title: ( localize2(5464, "Sign in to use AI features"))
-                });
-            }
-            async run(accessor) {
-                const commandService = accessor.get(ICommandService);
-                const telemetryService = accessor.get(ITelemetryService);
-                telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'api' });
-                return commandService.executeCommand(CHAT_SETUP_ACTION_ID, undefined, { forceSignInDialog: true });
-            }
-        }
-        class ChatSetupTriggerAnonymousWithoutDialogAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.action.chat.triggerSetupAnonymousWithoutDialog',
-                    title: ChatSetupTriggerAction.CHAT_SETUP_ACTION_LABEL
-                });
-            }
-            async run(accessor) {
-                const commandService = accessor.get(ICommandService);
-                const telemetryService = accessor.get(ITelemetryService);
-                telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'api' });
-                return commandService.executeCommand(CHAT_SETUP_ACTION_ID, undefined, { forceAnonymous: ChatSetupAnonymous.EnabledWithoutDialog });
-            }
-        }
-        class ChatSetupFromAccountsAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.action.chat.triggerSetupFromAccounts',
-                    title: ( localize2(5465, "Sign in to use AI features...")),
-                    menu: {
-                        id: MenuId.AccountsContext,
-                        group: '2_copilot',
-                        when: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.installed.negate()), ChatContextKeys.Entitlement.signedOut))
-                    }
-                });
-            }
-            async run(accessor) {
-                const commandService = accessor.get(ICommandService);
-                const telemetryService = accessor.get(ITelemetryService);
-                telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'accounts' });
-                return commandService.executeCommand(CHAT_SETUP_ACTION_ID);
-            }
-        }
-        const windowFocusListener = this._register(( new MutableDisposable()));
-        class UpgradePlanAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.action.chat.upgradePlan',
-                    title: ( localize2(5466, "Upgrade to GitHub Copilot Pro")),
-                    category: ( localize2(5467, 'Chat')),
-                    f1: true,
-                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ContextKeyExpr.or(
-                        ChatContextKeys.Entitlement.canSignUp,
-                        ChatContextKeys.Entitlement.planFree
-                    )))),
-                    menu: {
-                        id: MenuId.ChatTitleBarMenu,
-                        group: 'a_first',
-                        order: 1,
-                        when: ( ContextKeyExpr.and(ChatContextKeys.Entitlement.planFree, ( ContextKeyExpr.or(
-                            ChatContextKeys.chatQuotaExceeded,
-                            ChatContextKeys.completionsQuotaExceeded
-                        ))))
-                    }
-                });
-            }
-            async run(accessor) {
-                const openerService = accessor.get(IOpenerService);
-                const hostService = accessor.get(IHostService);
-                const commandService = accessor.get(ICommandService);
-                openerService.open(( URI.parse(defaultChat.upgradePlanUrl)));
-                const entitlement = context.state.entitlement;
-                if (!isProUser(entitlement)) {
-                    windowFocusListener.value = hostService.onDidChangeFocus(focus => this.onWindowFocus(focus, commandService));
-                }
-            }
-            async onWindowFocus(focus, commandService) {
-                if (focus) {
-                    windowFocusListener.clear();
-                    const entitlements = await requests.forceResolveEntitlement(undefined);
-                    if (entitlements?.entitlement && isProUser(entitlements?.entitlement)) {
-                        refreshTokens(commandService);
-                    }
-                }
-            }
-        }
-        class EnableOveragesAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.action.chat.manageOverages',
-                    title: ( localize2(5468, "Manage GitHub Copilot Overages")),
-                    category: ( localize2(5467, 'Chat')),
-                    f1: true,
-                    precondition: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ContextKeyExpr.or(
-                        ChatContextKeys.Entitlement.planPro,
-                        ChatContextKeys.Entitlement.planProPlus
-                    )))),
-                    menu: {
-                        id: MenuId.ChatTitleBarMenu,
-                        group: 'a_first',
-                        order: 1,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.or(
-                            ChatContextKeys.Entitlement.planPro,
-                            ChatContextKeys.Entitlement.planProPlus
-                        )), ( ContextKeyExpr.or(
-                            ChatContextKeys.chatQuotaExceeded,
-                            ChatContextKeys.completionsQuotaExceeded
-                        ))))
-                    }
-                });
-            }
-            async run(accessor) {
-                const openerService = accessor.get(IOpenerService);
-                openerService.open(( URI.parse(defaultChat.manageOveragesUrl)));
-            }
-        }
-        registerAction2(ChatSetupTriggerAction);
-        registerAction2(ChatSetupTriggerForceSignInDialogAction);
-        registerAction2(ChatSetupFromAccountsAction);
-        registerAction2(ChatSetupTriggerAnonymousWithoutDialogAction);
-        registerAction2(ChatSetupTriggerSupportAnonymousAction);
-        registerAction2(UpgradePlanAction);
-        registerAction2(EnableOveragesAction);
-    }
-    registerUrlLinkHandler() {
-        this._register(ExtensionUrlHandlerOverrideRegistry.registerHandler({
-            canHandleURL: url => {
-                return url.scheme === this.productService.urlProtocol && equalsIgnoreCase(url.authority, defaultChat.chatExtensionId);
-            },
-            handleURL: async (url) => {
-                const params = ( new URLSearchParams(url.query));
-                this.telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'url', detail: params.get('referrer') ?? undefined });
-                const agentParam = params.get('agent') ?? params.get('mode');
-                if (agentParam) {
-                    const agents = this.chatModeService.getModes();
-                    const allAgents = [...agents.builtin, ...agents.custom];
-                    let foundAgent = allAgents.find(agent => agent.id === agentParam);
-                    if (!foundAgent) {
-                        const nameLower = agentParam.toLowerCase();
-                        foundAgent = allAgents.find(agent => agent.name.get().toLowerCase() === nameLower);
-                    }
-                    await this.commandService.executeCommand(CHAT_SETUP_ACTION_ID, foundAgent?.id);
-                    return true;
-                }
-                return false;
-            }
-        }));
-    }
-    async checkExtensionInstallation(context) {
-        if (this.environmentService.isExtensionDevelopment) {
-            await this.extensionService.whenInstalledExtensionsRegistered();
-            if (this.extensionService.extensions.find(ext => ExtensionIdentifier.equals(ext.identifier, defaultChat.chatExtensionId))) {
-                context.update({ installed: true, disabled: false, untrusted: false });
-                return;
-            }
-        }
-        await this.extensionsWorkbenchService.queryLocal();
-        this._register(Event.runAndSubscribe(this.extensionsWorkbenchService.onChange, e => {
-            if (e && !ExtensionIdentifier.equals(e.identifier.id, defaultChat.chatExtensionId)) {
-                return;
-            }
-            const defaultChatExtension = this.extensionsWorkbenchService.local.find(value => ExtensionIdentifier.equals(value.identifier.id, defaultChat.chatExtensionId));
-            const installed = !!defaultChatExtension?.local;
-            let disabled;
-            let untrusted = false;
-            if (installed) {
-                disabled = !this.extensionEnablementService.isEnabled(defaultChatExtension.local);
-                if (disabled) {
-                    const state = this.extensionEnablementService.getEnablementState(defaultChatExtension.local);
-                    if (state === EnablementState.DisabledByTrustRequirement) {
-                        disabled = false;
-                        untrusted = true;
-                    }
-                }
-            }
-            else {
-                disabled = false;
-            }
-            context.update({ installed, disabled, untrusted });
-        }));
-    }
-};
-ChatSetupContribution = ( __decorate([
-    ( __param(0, IProductService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ICommandService)),
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IChatEntitlementService)),
-    ( __param(5, IChatModeService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IWorkbenchExtensionEnablementService)),
-    ( __param(9, IExtensionsWorkbenchService)),
-    ( __param(10, IExtensionService)),
-    ( __param(11, IEnvironmentService)),
-    ( __param(12, IConfigurationService))
-], ChatSetupContribution));
-let ChatTeardownContribution = class ChatTeardownContribution extends Disposable {
-    static { ChatTeardownContribution_1 = this; }
-    static { this.ID = 'workbench.contrib.chatTeardown'; }
-    static { this.CHAT_DISABLED_CONFIGURATION_KEY = 'chat.disableAIFeatures'; }
-    constructor(chatEntitlementService, configurationService, extensionsWorkbenchService, extensionEnablementService, viewDescriptorService, layoutService) {
-        super();
-        this.configurationService = configurationService;
-        this.extensionsWorkbenchService = extensionsWorkbenchService;
-        this.extensionEnablementService = extensionEnablementService;
-        this.viewDescriptorService = viewDescriptorService;
-        this.layoutService = layoutService;
-        const context = chatEntitlementService.context?.value;
-        if (!context) {
-            return;
-        }
-        this.registerListeners();
-        this.registerActions();
-        this.handleChatDisabled(false);
-    }
-    handleChatDisabled(fromEvent) {
-        const chatDisabled = this.configurationService.inspect(ChatTeardownContribution_1.CHAT_DISABLED_CONFIGURATION_KEY);
-        if (chatDisabled.value === true) {
-            this.maybeEnableOrDisableExtension(typeof chatDisabled.workspaceValue === 'boolean' ? EnablementState.DisabledWorkspace : EnablementState.DisabledGlobally);
-            if (fromEvent) {
-                this.maybeHideAuxiliaryBar();
-            }
-        }
-        else if (chatDisabled.value === false && fromEvent ) {
-            this.maybeEnableOrDisableExtension(typeof chatDisabled.workspaceValue === 'boolean' ? EnablementState.EnabledWorkspace : EnablementState.EnabledGlobally);
-        }
-    }
-    async registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (!e.affectsConfiguration(ChatTeardownContribution_1.CHAT_DISABLED_CONFIGURATION_KEY)) {
-                return;
-            }
-            this.handleChatDisabled(true);
-        }));
-        await this.extensionsWorkbenchService.queryLocal();
-        this._register(this.extensionsWorkbenchService.onChange(e => {
-            if (e && !ExtensionIdentifier.equals(e.identifier.id, defaultChat.chatExtensionId)) {
-                return;
-            }
-            const defaultChatExtension = this.extensionsWorkbenchService.local.find(value => ExtensionIdentifier.equals(value.identifier.id, defaultChat.chatExtensionId));
-            if (defaultChatExtension?.local && this.extensionEnablementService.isEnabled(defaultChatExtension.local)) {
-                this.configurationService.updateValue(ChatTeardownContribution_1.CHAT_DISABLED_CONFIGURATION_KEY, false);
-            }
-        }));
-    }
-    async maybeEnableOrDisableExtension(state) {
-        const defaultChatExtension = this.extensionsWorkbenchService.local.find(value => ExtensionIdentifier.equals(value.identifier.id, defaultChat.chatExtensionId));
-        if (!defaultChatExtension) {
-            return;
-        }
-        await this.extensionsWorkbenchService.setEnablement([defaultChatExtension], state);
-        await this.extensionsWorkbenchService.updateRunningExtensions(state === EnablementState.EnabledGlobally || state === EnablementState.EnabledWorkspace ? ( localize(5469, "Enabling AI features")) : ( localize(5470, "Disabling AI features")));
-    }
-    maybeHideAuxiliaryBar() {
-        const activeContainers = this.viewDescriptorService.getViewContainersByLocation(ViewContainerLocation.AuxiliaryBar).filter(container => this.viewDescriptorService.getViewContainerModel(container).activeViewDescriptors.length > 0);
-        if ((activeContainers.length === 0) ||
-            (activeContainers.length === 1 && activeContainers.at(0)?.id === CHAT_SIDEBAR_PANEL_ID)
-        ) {
-            this.layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
-        }
-    }
-    registerActions() {
-        class ChatSetupHideAction extends Action2 {
-            static { this.ID = 'workbench.action.chat.hideSetup'; }
-            static { this.TITLE = ( localize2(5471, "Learn How to Hide AI Features")); }
-            constructor() {
-                super({
-                    id: ChatSetupHideAction.ID,
-                    title: ChatSetupHideAction.TITLE,
-                    f1: true,
-                    category: CHAT_CATEGORY,
-                    precondition: ( ChatContextKeys.Setup.hidden.negate()),
-                    menu: {
-                        id: MenuId.ChatTitleBarMenu,
-                        group: 'z_hide',
-                        order: 1,
-                        when: ( ChatContextKeys.Setup.installed.negate())
-                    }
-                });
-            }
-            async run(accessor) {
-                const preferencesService = accessor.get(IPreferencesService);
-                preferencesService.openSettings({ jsonEditor: false, query: `@id:${ChatTeardownContribution_1.CHAT_DISABLED_CONFIGURATION_KEY}` });
-            }
-        }
-        registerAction2(ChatSetupHideAction);
-    }
-};
-ChatTeardownContribution = ChatTeardownContribution_1 = ( __decorate([
-    ( __param(0, IChatEntitlementService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IExtensionsWorkbenchService)),
-    ( __param(3, IWorkbenchExtensionEnablementService)),
-    ( __param(4, IViewDescriptorService)),
-    ( __param(5, IWorkbenchLayoutService))
-], ChatTeardownContribution));
-var ChatSetupStep;
-(function (ChatSetupStep) {
-    ChatSetupStep[ChatSetupStep["Initial"] = 1] = "Initial";
-    ChatSetupStep[ChatSetupStep["SigningIn"] = 2] = "SigningIn";
-    ChatSetupStep[ChatSetupStep["Installing"] = 3] = "Installing";
-})(ChatSetupStep || (ChatSetupStep = {}));
-let ChatSetupController = class ChatSetupController extends Disposable {
-    get step() { return this._step; }
-    constructor(context, requests, telemetryService, authenticationService, extensionsWorkbenchService, productService, logService, progressService, activityService, commandService, dialogService, configurationService, lifecycleService, quickInputService) {
-        super();
-        this.context = context;
-        this.requests = requests;
-        this.telemetryService = telemetryService;
-        this.authenticationService = authenticationService;
-        this.extensionsWorkbenchService = extensionsWorkbenchService;
-        this.productService = productService;
-        this.logService = logService;
-        this.progressService = progressService;
-        this.activityService = activityService;
-        this.commandService = commandService;
-        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.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.context.onDidChange(() => this._onDidChange.fire()));
-    }
-    setStep(step) {
-        if (this._step === step) {
-            return;
-        }
-        this._step = step;
-        this._onDidChange.fire();
-    }
-    async setup(options = {}) {
-        const watch = ( new StopWatch(false));
-        const title = ( localize(5472, "Getting chat ready..."));
-        const badge = this.activityService.showViewContainerActivity(CHAT_SIDEBAR_PANEL_ID, {
-            badge: ( new ProgressBadge(() => title)),
-        });
-        try {
-            return await this.progressService.withProgress({
-                location: ProgressLocation.Window,
-                command: CHAT_OPEN_ACTION_ID,
-                title,
-            }, () => this.doSetup(options, watch));
-        }
-        finally {
-            badge.dispose();
-        }
-    }
-    async doSetup(options, watch) {
-        this.context.suspend();
-        let success = false;
-        try {
-            const providerId = ChatEntitlementRequests.providerId(this.configurationService);
-            let session;
-            let entitlement;
-            let signIn;
-            if (options.forceSignIn) {
-                signIn = true;
-            }
-            else if (this.context.state.entitlement === ChatEntitlement.Unknown) {
-                if (options.forceAnonymous) {
-                    signIn = false;
-                }
-                else {
-                    signIn = true;
-                }
-            }
-            else {
-                signIn = false;
-            }
-            if (signIn) {
-                this.setStep(ChatSetupStep.SigningIn);
-                const result = await this.signIn(options);
-                if (!result.session) {
-                    this.doInstall();
-                    const provider = options.useSocialProvider ?? (options.useEnterpriseProvider ? defaultChat.provider.enterprise.id : defaultChat.provider.default.id);
-                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotSignedIn', installDuration: watch.elapsed(), signUpErrorCode: undefined, provider });
-                    return undefined;
-                }
-                session = result.session;
-                entitlement = result.entitlement;
-            }
-            this.setStep(ChatSetupStep.Installing);
-            success = await this.install(session, entitlement ?? this.context.state.entitlement, providerId, watch, options);
-        }
-        finally {
-            this.setStep(ChatSetupStep.Initial);
-            this.context.resume();
-        }
-        return success;
-    }
-    async signIn(options) {
-        let session;
-        let entitlements;
-        try {
-            ({ session, entitlements } = await this.requests.signIn(options));
-        }
-        catch (e) {
-            this.logService.error(`[chat setup] signIn: error ${e}`);
-        }
-        if (!session && !this.lifecycleService.willShutdown) {
-            const { confirmed } = await this.dialogService.confirm({
-                type: Severity.Error,
-                message: ( localize(
-                    5473,
-                    "Failed to sign in to {0}. Would you like to try again?",
-                    ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id ? defaultChat.provider.enterprise.name : defaultChat.provider.default.name
-                )),
-                detail: ( localize(5474, "You must be signed in to use AI features.")),
-                primaryButton: ( localize(5463, "Retry"))
-            });
-            if (confirmed) {
-                return this.signIn(options);
-            }
-        }
-        return { session, entitlement: entitlements?.entitlement };
-    }
-    async install(session, entitlement, providerId, watch, options) {
-        const wasRunning = this.context.state.installed && !this.context.state.disabled;
-        let signUpResult = undefined;
-        let provider;
-        if (options.forceAnonymous && entitlement === ChatEntitlement.Unknown) {
-            provider = 'anonymous';
-        }
-        else {
-            provider = options.useSocialProvider ?? (options.useEnterpriseProvider ? defaultChat.provider.enterprise.id : defaultChat.provider.default.id);
-        }
-        let sessions = session ? [session] : undefined;
-        try {
-            if (!options.forceAnonymous &&
-                entitlement !== ChatEntitlement.Free &&
-                !isProUser(entitlement) &&
-                entitlement !== ChatEntitlement.Unavailable
-            ) {
-                if (!sessions) {
-                    try {
-                        const existingSessions = await this.authenticationService.getSessions(providerId);
-                        sessions = existingSessions.length > 0 ? [...existingSessions] : undefined;
-                    }
-                    catch (error) {
-                    }
-                    if (!sessions || sessions.length === 0) {
-                        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNoSession', installDuration: watch.elapsed(), signUpErrorCode: undefined, provider });
-                        return false;
-                    }
-                }
-                signUpResult = await this.requests.signUpFree(sessions);
-                if (typeof signUpResult !== 'boolean' ) {
-                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedSignUp', installDuration: watch.elapsed(), signUpErrorCode: signUpResult.errorCode, provider });
-                }
-            }
-            await this.doInstallWithRetry();
-        }
-        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, provider });
-            return false;
-        }
-        if (typeof signUpResult === 'boolean'  || typeof signUpResult === 'undefined' ) {
-            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: wasRunning && !signUpResult ? 'alreadyInstalled' : 'installed', installDuration: watch.elapsed(), signUpErrorCode: undefined, provider });
-        }
-        if (wasRunning) {
-            refreshTokens(this.commandService);
-        }
-        return true;
-    }
-    async doInstallWithRetry() {
-        let error;
-        try {
-            await this.doInstall();
-        }
-        catch (e) {
-            this.logService.error(`[chat setup] install: error ${error}`);
-            error = e;
-        }
-        if (error) {
-            if (!this.lifecycleService.willShutdown) {
-                const { confirmed } = await this.dialogService.confirm({
-                    type: Severity.Error,
-                    message: ( localize(
-                        5475,
-                        "An error occurred while setting up chat. Would you like to try again?"
-                    )),
-                    detail: error && !isCancellationError(error) ? toErrorMessage(error) : undefined,
-                    primaryButton: ( localize(5463, "Retry"))
-                });
-                if (confirmed) {
-                    return this.doInstallWithRetry();
-                }
-            }
-            throw error;
-        }
-    }
-    async doInstall() {
-        await this.extensionsWorkbenchService.install(defaultChat.chatExtensionId, {
-            enable: true,
-            isApplicationScoped: true,
-            isMachineScoped: false,
-            installEverywhere: true,
-            installPreReleaseVersion: this.productService.quality !== 'stable'
-        }, ChatViewId);
-    }
-    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) {
-                this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedEnterpriseSetup', installDuration: 0, signUpErrorCode: undefined, provider: undefined });
-                return success;
-            }
-        }
-        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.provider.enterprise.id
-            }, ConfigurationTarget.USER);
-        }
-        else {
-            await this.configurationService.updateValue(`${defaultChat.completionsAdvancedSetting}`, ( Object.keys(existingAdvancedSetting)).length > 0 ? {
-                ...existingAdvancedSetting,
-                'authProvider': undefined
-            } : 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(5476, "What is your {0} instance?", defaultChat.provider.enterprise.name)),
-            placeHolder: ( localize(5477, '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(5478, "Will resolve to {0}", `https://${value}.ghe.com`)),
-                        severity: Severity.Info
-                    };
-                }
-                if (!fullUriRegEx.test(value)) {
-                    return {
-                        content: ( localize(
-                            5479,
-                            'You must enter a valid {0} instance (i.e. "octocat" or "https://octocat.ghe.com")',
-                            defaultChat.provider.enterprise.name
-                        )),
-                        severity: Severity.Error
-                    };
-                }
-                return undefined;
-            }
-        });
-        if (!result) {
-            return undefined;
-        }
-        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, IExtensionsWorkbenchService)),
-    ( __param(5, IProductService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IProgressService)),
-    ( __param(8, IActivityService)),
-    ( __param(9, ICommandService)),
-    ( __param(10, IDialogService)),
-    ( __param(11, IConfigurationService)),
-    ( __param(12, ILifecycleService)),
-    ( __param(13, IQuickInputService))
-], ChatSetupController));
-function refreshTokens(commandService) {
-    commandService.executeCommand(defaultChat.completionsRefreshTokenCommand);
-    commandService.executeCommand(defaultChat.chatRefreshTokenCommand);
-}
-
-export { ChatSetupContribution, ChatTeardownContribution };