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

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

@@ -0,0 +1,622 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable, markAsSingleton, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { equalsIgnoreCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId, registerAction2, MenuRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.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 { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.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 { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.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 { ChatEntitlement, 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 { 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-api/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
+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 { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { CHAT_CATEGORY, CHAT_SETUP_ACTION_ID, CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { AGENT_SESSIONS_VIEW_CONTAINER_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { ChatViewContainerId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { chatViewsWelcomeRegistry } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcome';
+import { ChatSetupAnonymous } from './chatSetup.js';
+import { ChatSetupController } from './chatSetupController.js';
+import { SetupAgent, AINewSymbolNamesProvider, ChatCodeActionsProvider, AICodeActionsHelper } from './chatSetupProviders.js';
+import { ChatSetup } from './chatSetupRunner.js';
+
+var ChatTeardownContribution_1;
+const defaultChat = {
+    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
+    manageOveragesUrl: product.defaultChatAgent?.manageOverageUrl ?? '',
+    upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',
+    completionsRefreshTokenCommand: product.defaultChatAgent?.completionsRefreshTokenCommand ?? '',
+    chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? '',
+};
+let ChatSetupContribution = class ChatSetupContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.chatSetup'; }
+    constructor(instantiationService, chatEntitlementService, logService, contextKeyService, extensionEnablementService, extensionsWorkbenchService, extensionService, environmentService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.contextKeyService = contextKeyService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.extensionService = extensionService;
+        this.environmentService = environmentService;
+        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) {
+        const defaultAgentDisposables = markAsSingleton(( new MutableDisposable()));
+        const vscodeAgentDisposables = markAsSingleton(( new MutableDisposable()));
+        const renameProviderDisposables = markAsSingleton(( new MutableDisposable()));
+        const codeActionsProviderDisposables = 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 = AINewSymbolNamesProvider.registerProvider(this.instantiationService, context, controller);
+                    }
+                }
+                else {
+                    renameProviderDisposables.clear();
+                }
+            }
+            {
+                if (!context.state.installed && !context.state.hidden && !context.state.disabled) {
+                    if (!codeActionsProviderDisposables.value) {
+                        codeActionsProviderDisposables.value = ChatCodeActionsProvider.registerProvider(this.instantiationService);
+                    }
+                }
+                else {
+                    codeActionsProviderDisposables.clear();
+                }
+            }
+        };
+        this._register(Event.runAndSubscribe(context.onDidChange, () => updateRegistration()));
+    }
+    registerActions(context, requests, controller) {
+        class ChatSetupTriggerAction extends Action2 {
+            static { this.CHAT_SETUP_ACTION_LABEL = ( localize2(5520, "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 widgetService = accessor.get(IChatWidgetService);
+                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 widgetService.revealWidget();
+                    chatWidget?.input.setChatMode(mode);
+                }
+                if (options?.inputValue) {
+                    const chatWidget = await widgetService.revealWidget();
+                    chatWidget?.setInput(options.inputValue);
+                }
+                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(5521, "Chat setup failed. Would you like to try again?")),
+                        primaryButton: ( localize(5522, "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(5523, "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(5524, "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(5525, "Upgrade to GitHub Copilot Pro")),
+                    category: ( localize2(5526, '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(5527, "Manage GitHub Copilot Overages")),
+                    category: ( localize2(5526, '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);
+        function registerGenerateCodeCommand(coreCommand, actualCommand) {
+            CommandsRegistry.registerCommand(coreCommand, async (accessor) => {
+                const commandService = accessor.get(ICommandService);
+                const codeEditorService = accessor.get(ICodeEditorService);
+                const markerService = accessor.get(IMarkerService);
+                switch (coreCommand) {
+                    case 'chat.internal.explain':
+                    case 'chat.internal.fix': {
+                        const textEditor = codeEditorService.getActiveCodeEditor();
+                        const uri = textEditor?.getModel()?.uri;
+                        const range = textEditor?.getSelection();
+                        if (!uri || !range) {
+                            return;
+                        }
+                        const markers = AICodeActionsHelper.warningOrErrorMarkersAtRange(markerService, uri, range);
+                        const actualCommand = coreCommand === 'chat.internal.explain'
+                            ? AICodeActionsHelper.explainMarkers(markers)
+                            : AICodeActionsHelper.fixMarkers(markers, range);
+                        await commandService.executeCommand(actualCommand.id, ...(actualCommand.arguments ?? []));
+                        break;
+                    }
+                    case 'chat.internal.review':
+                    case 'chat.internal.generateDocs':
+                    case 'chat.internal.generateTests': {
+                        const result = await commandService.executeCommand(CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID);
+                        if (result) {
+                            await commandService.executeCommand(actualCommand);
+                        }
+                    }
+                }
+            });
+        }
+        registerGenerateCodeCommand('chat.internal.explain', 'github.copilot.chat.explain');
+        registerGenerateCodeCommand('chat.internal.fix', 'github.copilot.chat.fix');
+        registerGenerateCodeCommand('chat.internal.review', 'github.copilot.chat.review');
+        registerGenerateCodeCommand('chat.internal.generateDocs', 'github.copilot.chat.generateDocs');
+        registerGenerateCodeCommand('chat.internal.generateTests', 'github.copilot.chat.generateTests');
+        const internalGenerateCodeContext = ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.disabled.negate()), ( ChatContextKeys.Setup.installed.negate())));
+        MenuRegistry.appendMenuItem(MenuId.EditorContext, {
+            command: {
+                id: 'chat.internal.explain',
+                title: ( localize(5528, "Explain")),
+            },
+            group: '1_chat',
+            order: 4,
+            when: internalGenerateCodeContext
+        });
+        MenuRegistry.appendMenuItem(MenuId.ChatTextEditorMenu, {
+            command: {
+                id: 'chat.internal.fix',
+                title: ( localize(5529, "Fix")),
+            },
+            group: '1_action',
+            order: 1,
+            when: ( ContextKeyExpr.and(internalGenerateCodeContext, ( EditorContextKeys.readOnly.negate())))
+        });
+        MenuRegistry.appendMenuItem(MenuId.ChatTextEditorMenu, {
+            command: {
+                id: 'chat.internal.review',
+                title: ( localize(5530, "Code Review")),
+            },
+            group: '1_action',
+            order: 2,
+            when: internalGenerateCodeContext
+        });
+        MenuRegistry.appendMenuItem(MenuId.ChatTextEditorMenu, {
+            command: {
+                id: 'chat.internal.generateDocs',
+                title: ( localize(5531, "Generate Docs")),
+            },
+            group: '2_generate',
+            order: 1,
+            when: ( ContextKeyExpr.and(internalGenerateCodeContext, ( EditorContextKeys.readOnly.negate())))
+        });
+        MenuRegistry.appendMenuItem(MenuId.ChatTextEditorMenu, {
+            command: {
+                id: 'chat.internal.generateTests',
+                title: ( localize(5532, "Generate Tests")),
+            },
+            group: '2_generate',
+            order: 2,
+            when: ( ContextKeyExpr.and(internalGenerateCodeContext, ( EditorContextKeys.readOnly.negate())))
+        });
+    }
+    registerUrlLinkHandler() {
+        this._register(ExtensionUrlHandlerOverrideRegistry.registerHandler(this.instantiationService.createInstance(ChatSetupExtensionUrlHandler)));
+    }
+    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, IInstantiationService)),
+    ( __param(1, IChatEntitlementService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IWorkbenchExtensionEnablementService)),
+    ( __param(5, IExtensionsWorkbenchService)),
+    ( __param(6, IExtensionService)),
+    ( __param(7, IEnvironmentService))
+], ChatSetupContribution));
+let ChatSetupExtensionUrlHandler = class ChatSetupExtensionUrlHandler {
+    constructor(productService, commandService, telemetryService, chatModeService) {
+        this.productService = productService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.chatModeService = chatModeService;
+    }
+    canHandleURL(url) {
+        return url.scheme === this.productService.urlProtocol && equalsIgnoreCase(url.authority, defaultChat.chatExtensionId);
+    }
+    async handleURL(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');
+        const inputParam = params.get('prompt');
+        if (!agentParam && !inputParam) {
+            return false;
+        }
+        const agentId = agentParam ? this.resolveAgentId(agentParam) : undefined;
+        await this.commandService.executeCommand(CHAT_SETUP_ACTION_ID, agentId, inputParam ? { inputValue: inputParam } : undefined);
+        return true;
+    }
+    resolveAgentId(agentParam) {
+        const agents = this.chatModeService.getModes();
+        const allAgents = [...agents.builtin, ...agents.custom];
+        const foundAgent = allAgents.find(agent => agent.id === agentParam);
+        if (foundAgent) {
+            return foundAgent.id;
+        }
+        const nameLower = agentParam.toLowerCase();
+        const agentByName = allAgents.find(agent => agent.name.get().toLowerCase() === nameLower);
+        return agentByName?.id;
+    }
+};
+ChatSetupExtensionUrlHandler = ( __decorate([
+    ( __param(0, IProductService)),
+    ( __param(1, ICommandService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IChatModeService))
+], ChatSetupExtensionUrlHandler));
+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(5533, "Enabling AI features")) : ( localize(5534, "Disabling AI features")));
+    }
+    maybeHideAuxiliaryBar() {
+        const activeContainers = this.viewDescriptorService.getViewContainersByLocation(ViewContainerLocation.AuxiliaryBar).filter(container => this.viewDescriptorService.getViewContainerModel(container).activeViewDescriptors.length > 0);
+        const hasChatView = ( activeContainers.some(container => container.id === ChatViewContainerId));
+        const hasAgentSessionsView = ( activeContainers.some(container => container.id === AGENT_SESSIONS_VIEW_CONTAINER_ID));
+        if ((activeContainers.length === 0) ||
+            (activeContainers.length === 1 && (hasChatView || hasAgentSessionsView)) ||
+            (activeContainers.length === 2 && hasChatView && hasAgentSessionsView)
+        ) {
+            this.layoutService.setPartHidden(true, Parts.AUXILIARYBAR_PART);
+        }
+    }
+    registerActions() {
+        class ChatSetupHideAction extends Action2 {
+            static { this.ID = 'workbench.action.chat.hideSetup'; }
+            static { this.TITLE = ( localize2(5535, "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));
+function refreshTokens(commandService) {
+    commandService.executeCommand(defaultChat.completionsRefreshTokenCommand);
+    commandService.executeCommand(defaultChat.chatRefreshTokenCommand);
+}
+
+export { ChatSetupContribution, ChatTeardownContribution, refreshTokens };