@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -7,7 +7,6 @@ import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/comm
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-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 { 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';
@@ -19,16 +18,18 @@ import { nullExtensionDescription } from '@codingame/monaco-vscode-api/vscode/vs
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
-import { ChatEntitlement, ChatEntitlementRequests } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { ChatEntitlement } 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-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
 import { ChatRequestToolPart, ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration, ChatModeKind, ChatAgentLocation } 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_OPEN_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ChatViewId } 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 { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
 import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
 import { Selection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
@@ -38,178 +39,391 @@ import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
 import { ChatSetupStep, ChatSetupAnonymous } from './chatSetup.js';
 import { ChatSetup } from './chatSetupRunner.js';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
 
 var SetupAgent_1, AINewSymbolNamesProvider_1, ChatCodeActionsProvider_1;
 const defaultChat = {
-    extensionId: product.defaultChatAgent?.extensionId ?? '',
-    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
-    provider: product.defaultChatAgent?.provider ?? { default: { id: '', name: '' }, enterprise: { id: '', name: '' }, apple: { id: '', name: '' }, google: { id: '', name: '' } },
+    extensionId: product.defaultChatAgent?.extensionId ?? "",
+    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? "",
+    provider: product.defaultChatAgent?.provider ?? {
+        default: {
+            id: "",
+            name: ""
+        },
+        enterprise: {
+            id: "",
+            name: ""
+        },
+        apple: {
+            id: "",
+            name: ""
+        },
+        google: {
+            id: "",
+            name: ""
+        }
+    },
+    outputChannelId: product.defaultChatAgent?.chatExtensionOutputId ?? ""
 };
 const ToolsAgentContextKey = ( ContextKeyExpr.and(( ContextKeyExpr.equals(`config.${ChatConfiguration.AgentEnabled}`, true)),
 ContextKeyExpr.not(`previewFeaturesDisabled`)));
 let SetupAgent = class SetupAgent extends Disposable {
-    static { SetupAgent_1 = this; }
+    static {
+        SetupAgent_1 = this;
+    }
     static registerDefaultAgents(instantiationService, location, mode, context, controller) {
         return instantiationService.invokeFunction(accessor => {
             const chatAgentService = accessor.get(IChatAgentService);
+            let description;
+            if (mode === ChatModeKind.Ask) {
+                description = ChatMode.Ask.description.get();
+            } else if (mode === ChatModeKind.Edit) {
+                description = ChatMode.Edit.description.get();
+            } else {
+                description = ChatMode.Agent.description.get();
+            }
             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;
+            case ChatAgentLocation.Chat:
+                if (mode === ChatModeKind.Ask) {
+                    id = "setup.chat";
+                } else if (mode === ChatModeKind.Edit) {
+                    id = "setup.edits";
+                } else {
+                    id = "setup.agent";
+                }
+                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);
+            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(5354, "Ask questions about VS Code")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            const {
+                disposable: vscodeDisposable
+            } = SetupAgent_1.doRegisterAgent(
+                instantiationService,
+                chatAgentService,
+                "setup.vscode",
+                "vscode",
+                false,
+                ( localize2(5546, "Ask questions about VS Code")).value,
+                ChatAgentLocation.Chat,
+                ChatModeKind.Agent,
+                context,
+                controller
+            );
             disposables.add(vscodeDisposable);
-            const { disposable: workspaceDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.workspace', 'workspace', false, ( localize2(5355, "Ask about your workspace")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            const {
+                disposable: workspaceDisposable
+            } = SetupAgent_1.doRegisterAgent(
+                instantiationService,
+                chatAgentService,
+                "setup.workspace",
+                "workspace",
+                false,
+                ( localize2(5547, "Ask about your workspace")).value,
+                ChatAgentLocation.Chat,
+                ChatModeKind.Agent,
+                context,
+                controller
+            );
             disposables.add(workspaceDisposable);
-            const { disposable: terminalDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.terminal.agent', 'terminal', false, ( localize2(5356, "Ask how to do something in the terminal")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            const {
+                disposable: terminalDisposable
+            } = SetupAgent_1.doRegisterAgent(
+                instantiationService,
+                chatAgentService,
+                "setup.terminal.agent",
+                "terminal",
+                false,
+                ( localize2(5548, "Ask how to do something in the terminal")).value,
+                ChatAgentLocation.Chat,
+                ChatModeKind.Agent,
+                context,
+                controller
+            );
             disposables.add(terminalDisposable);
             disposables.add(SetupTool.registerTool(instantiationService, {
-                id: 'setup_tools_createNewWorkspace',
+                id: "setup_tools_createNewWorkspace",
                 source: ToolDataSource.Internal,
                 icon: Codicon.newFolder,
-                displayName: ( localize(5357, "New Workspace")),
-                modelDescription: 'Scaffold a new workspace in VS Code',
-                userDescription: ( localize(5358, "Scaffold a new workspace in VS Code")),
+                displayName: ( localize(5549, "New Workspace")),
+                modelDescription: "Scaffold a new workspace in VS Code",
+                userDescription: ( localize(5550, "Scaffold a new workspace in VS Code")),
                 canBeReferencedInPrompt: true,
-                toolReferenceName: 'new',
-                when: ContextKeyExpr.true(),
+                toolReferenceName: "new",
+                when: ContextKeyExpr.true()
             }));
             return disposables;
         });
     }
-    static doRegisterAgent(instantiationService, chatAgentService, id, name, isDefault, description, location, mode, context, controller) {
+    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],
+            modes: [mode],
             when: mode === ChatModeKind.Agent ? ToolsAgentContextKey?.serialize() : undefined,
             slashCommands: [],
             disambiguation: [],
             locations: [location],
-            metadata: { helpTextPrefix: SetupAgent_1.SETUP_NEEDED_MESSAGE },
+            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));
+        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 });
+            chatAgentService.updateAgent(id, {
+                themeIcon: Codicon.tools
+            });
         }
-        return { agent, disposable: disposables };
+        return {
+            agent,
+            disposable: disposables
+        };
     }
-    static { this.SETUP_NEEDED_MESSAGE = ( new MarkdownString(( localize(5359, "You need to set up GitHub Copilot and be signed in to use Chat.")))); }
-    static { this.TRUST_NEEDED_MESSAGE = ( new MarkdownString(( localize(5360, "You need to trust this workspace to use Chat.")))); }
-    constructor(context, controller, location, instantiationService, logService, configurationService, telemetryService, environmentService, workspaceTrustManagementService, chatEntitlementService) {
+    static {
+        this.SETUP_NEEDED_MESSAGE = ( new MarkdownString(( localize(5551, "You need to set up GitHub Copilot and be signed in to use Chat."))));
+    }
+    static {
+        this.TRUST_NEEDED_MESSAGE = ( new MarkdownString(( localize(5552, "You need to trust this workspace to use Chat."))));
+    }
+    static {
+        this.CHAT_RETRY_COMMAND_ID = "workbench.action.chat.retrySetup";
+    }
+    constructor(
+        context,
+        controller,
+        location,
+        instantiationService,
+        logService,
+        telemetryService,
+        environmentService,
+        workspaceTrustManagementService,
+        chatEntitlementService,
+        viewsService
+    ) {
         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.viewsService = viewsService;
         this._onUnresolvableError = this._register(( new Emitter()));
         this.onUnresolvableError = this._onUnresolvableError.event;
         this.pendingForwardedRequests = ( new ResourceMap());
+        this.registerCommands();
+    }
+    registerCommands() {
+        this._register(
+            CommandsRegistry.registerCommand(SetupAgent_1.CHAT_RETRY_COMMAND_ID, async (accessor, sessionResource) => {
+                const hostService = accessor.get(IHostService);
+                const chatWidgetService = accessor.get(IChatWidgetService);
+                const widget = chatWidgetService.getWidgetBySessionResource(sessionResource);
+                await widget?.clear();
+                hostService.reload();
+            })
+        );
     }
     async invoke(request, progress) {
-        return this.instantiationService.invokeFunction(async (accessor ) => {
+        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);
+            const defaultAccountService = accessor.get(IDefaultAccountService);
+            return this.doInvoke(
+                request,
+                part => progress([part]),
+                chatService,
+                languageModelsService,
+                chatWidgetService,
+                chatAgentService,
+                languageModelToolsService,
+                defaultAccountService
+            );
         });
     }
-    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);
+    async doInvoke(
+        request,
+        progress,
+        chatService,
+        languageModelsService,
+        chatWidgetService,
+        chatAgentService,
+        languageModelToolsService,
+        defaultAccountService
+    ) {
+        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,
+                defaultAccountService
+            );
         }
-        return this.doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
-    }
-    async doInvokeWithoutSetup(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.getWidgetBySessionResource(request.sessionResource)?.viewModel?.model.getRequests().at(-1);
         if (!requestModel) {
-            this.logService.error('[chat setup] Request model not found, cannot redispatch request.');
+            this.logService.error("[chat setup] Request model not found, cannot redispatch request.");
             return {};
         }
         progress({
-            kind: 'progressMessage',
-            content: ( new MarkdownString(( localize(5361, "Getting chat ready...")))),
+            kind: "progressMessage",
+            content: ( new MarkdownString(( localize(5553, "Getting chat ready..."))))
         });
-        await this.forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+        await this.forwardRequestToChat(
+            requestModel,
+            progress,
+            chatService,
+            languageModelsService,
+            chatAgentService,
+            chatWidgetService,
+            languageModelToolsService
+        );
         return {};
     }
-    async forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+    async forwardRequestToChat(
+        requestModel,
+        progress,
+        chatService,
+        languageModelsService,
+        chatAgentService,
+        chatWidgetService,
+        languageModelToolsService
+    ) {
         try {
-            await this.doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
-        }
-        catch (error) {
-            this.logService.error('[chat setup] Failed to forward request to chat', error);
+            await this.doForwardRequestToChat(
+                requestModel,
+                progress,
+                chatService,
+                languageModelsService,
+                chatAgentService,
+                chatWidgetService,
+                languageModelToolsService
+            );
+        } catch (error) {
+            this.logService.error("[chat setup] Failed to forward request to chat", error);
             progress({
-                kind: 'warning',
-                content: ( new MarkdownString(( localize(5362, "Failed to get a response. Please try again."))))
+                kind: "warning",
+                content: ( new MarkdownString(( localize(5554, "Failed to get a response. Please try again."))))
             });
         }
     }
-    async doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+    async doForwardRequestToChat(
+        requestModel,
+        progress,
+        chatService,
+        languageModelsService,
+        chatAgentService,
+        chatWidgetService,
+        languageModelToolsService
+    ) {
         if (( this.pendingForwardedRequests.has(requestModel.session.sessionResource))) {
-            throw ( new Error('Request already in progress'));
+            throw ( new Error("Request already in progress"));
         }
-        const forwardRequest = this.doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+        const forwardRequest = this.doForwardRequestToChatWhenReady(
+            requestModel,
+            progress,
+            chatService,
+            languageModelsService,
+            chatAgentService,
+            chatWidgetService,
+            languageModelToolsService
+        );
         this.pendingForwardedRequests.set(requestModel.session.sessionResource, forwardRequest);
         try {
             await forwardRequest;
-        }
-        finally {
+        } finally {
             this.pendingForwardedRequests.delete(requestModel.session.sessionResource);
         }
     }
-    async doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+    async doForwardRequestToChatWhenReady(
+        requestModel,
+        progress,
+        chatService,
+        languageModelsService,
+        chatAgentService,
+        chatWidgetService,
+        languageModelToolsService
+    ) {
         const widget = chatWidgetService.getWidgetBySessionResource(requestModel.session.sessionResource);
         const modeInfo = widget?.input.currentModeInfo;
         let agentActivated = false;
@@ -218,38 +432,45 @@ let SetupAgent = class SetupAgent extends Disposable {
         let toolsModelReady = false;
         const whenAgentActivated = this.whenAgentActivated(chatService).then(() => agentActivated = true);
         const whenAgentReady = this.whenAgentReady(chatAgentService, modeInfo?.kind)?.then(() => agentReady = true);
+        if (!whenAgentReady) {
+            agentReady = true;
+        }
         const whenLanguageModelReady = this.whenLanguageModelReady(languageModelsService, requestModel.modelId)?.then(() => languageModelReady = true);
+        if (!whenLanguageModelReady) {
+            languageModelReady = true;
+        }
         const whenToolsModelReady = this.whenToolsModelReady(languageModelToolsService, requestModel)?.then(() => toolsModelReady = true);
+        if (!whenToolsModelReady) {
+            toolsModelReady = true;
+        }
         if (whenLanguageModelReady instanceof Promise || whenAgentReady instanceof Promise || whenToolsModelReady instanceof Promise) {
             const timeoutHandle = setTimeout(() => {
                 progress({
-                    kind: 'progressMessage',
-                    content: ( new MarkdownString(( localize(5363, "Chat is almost ready...")))),
+                    kind: "progressMessage",
+                    content: ( new MarkdownString(( localize(5555, "Chat is almost ready..."))))
                 });
             }, 10000);
             try {
-                const ready = await Promise.race([
-                    timeout(this.environmentService.remoteAuthority ? 60000  : 20000).then(() => 'timedout'),
-                    Promise.allSettled([
-                        whenAgentActivated,
-                        whenAgentReady,
-                        whenLanguageModelReady,
-                        whenToolsModelReady
-                    ])
-                ]);
-                if (ready === 'timedout') {
+                const ready = await Promise.race([timeout(
+                    this.environmentService.remoteAuthority ? 60000  : 20000
+                ).then(() => "timedout"), Promise.allSettled([
+                    whenAgentActivated,
+                    whenAgentReady,
+                    whenLanguageModelReady,
+                    whenToolsModelReady
+                ])]);
+                if (ready === "timedout") {
                     let warningMessage;
                     if (this.chatEntitlementService.anonymous) {
                         warningMessage = ( localize(
-                            5364,
-                            "Chat took too long to get ready. Please ensure that the extension `{0}` is installed and enabled.",
+                            5556,
+                            "Chat took too long to get ready. Please ensure that the extension `{0}` is installed and enabled. Click restart to try again if this issue persists.",
                             defaultChat.chatExtensionId
                         ));
-                    }
-                    else {
+                    } else {
                         warningMessage = ( localize(
-                            5365,
-                            "Chat took too long to get ready. Please ensure you are signed in to {0} and that the extension `{1}` is installed and enabled.",
+                            5557,
+                            "Chat took too long to get ready. Please ensure you are signed in to {0} and that the extension `{1}` is installed and enabled. Click restart to try again if this issue persists.",
                             defaultChat.provider.default.name,
                             defaultChat.chatExtensionId
                         ));
@@ -260,15 +481,33 @@ let SetupAgent = class SetupAgent extends Disposable {
                         languageModelReady,
                         toolsModelReady
                     });
+                    const chatViewPane = this.viewsService.getActiveViewWithId(ChatViewId);
+                    const matchingWelcomeView = chatViewPane?.getMatchingWelcomeView();
+                    this.telemetryService.publicLog2("chatSetup.timeout", {
+                        agentActivated,
+                        agentReady,
+                        languageModelReady,
+                        toolsModelReady,
+                        isRemote: !!this.environmentService.remoteAuthority,
+                        isAnonymous: this.chatEntitlementService.anonymous,
+                        matchingWelcomeViewWhen: matchingWelcomeView?.when.serialize() ?? (chatViewPane ? "noWelcomeView" : "noChatViewPane")
+                    });
                     progress({
-                        kind: 'warning',
+                        kind: "warning",
                         content: ( new MarkdownString(warningMessage))
                     });
+                    progress({
+                        kind: "command",
+                        command: {
+                            id: SetupAgent_1.CHAT_RETRY_COMMAND_ID,
+                            title: ( localize(5558, "Restart")),
+                            arguments: [requestModel.session.sessionResource]
+                        }
+                    });
                     this._onUnresolvableError.fire();
                     return;
                 }
-            }
-            finally {
+            } finally {
                 clearTimeout(timeoutHandle);
             }
         }
@@ -285,7 +524,7 @@ let SetupAgent = class SetupAgent extends Disposable {
             }
             for (const id of languageModelsService.getLanguageModelIds()) {
                 const model = languageModelsService.lookupLanguageModel(id);
-                if (model?.isDefault) {
+                if (model?.isDefaultForLocation[ChatAgentLocation.Chat]) {
                     return true;
                 }
             }
@@ -294,21 +533,24 @@ let SetupAgent = class SetupAgent extends Disposable {
         if (hasModelForRequest()) {
             return;
         }
-        return Event.toPromise(Event.filter(languageModelsService.onDidChangeLanguageModels, () => hasModelForRequest()));
+        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_')) {
+        for (const tool of languageModelToolsService.getAllToolsIncludingDisabled()) {
+            if (tool.id.startsWith("copilot_")) {
                 return;
             }
         }
         return Event.toPromise(Event.filter(languageModelToolsService.onDidChangeTools, () => {
-            for (const tool of languageModelToolsService.getTools()) {
-                if (tool.id.startsWith('copilot_')) {
+            for (const tool of languageModelToolsService.getAllToolsIncludingDisabled()) {
+                if (tool.id.startsWith("copilot_")) {
                     return true;
                 }
             }
@@ -328,33 +570,44 @@ let SetupAgent = class SetupAgent extends Disposable {
     async whenAgentActivated(chatService) {
         try {
             await chatService.activateDefaultAgent(this.location);
-        }
-        catch (error) {
+        } catch (error) {
             this.logService.error(error);
         }
     }
-    async doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
-        this.telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'chat' });
+    async doInvokeWithSetup(
+        request,
+        progress,
+        chatService,
+        languageModelsService,
+        chatWidgetService,
+        chatAgentService,
+        languageModelToolsService,
+        defaultAccountService
+    ) {
+        this.telemetryService.publicLog2("workbenchActionExecuted", {
+            id: CHAT_SETUP_ACTION_ID,
+            from: "chat"
+        });
         const widget = chatWidgetService.getWidgetBySessionResource(request.sessionResource);
         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(
-                            5366,
-                            "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(5367, "Getting chat ready...")))),
-                    });
-                    break;
+            case ChatSetupStep.SigningIn:
+                progress({
+                    kind: "progressMessage",
+                    content: ( new MarkdownString(( localize(
+                        5559,
+                        "Signing in to {0}...",
+                        defaultAccountService.getDefaultAccountAuthenticationProvider().name
+                    ))))
+                });
+                break;
+            case ChatSetupStep.Installing:
+                progress({
+                    kind: "progressMessage",
+                    content: ( new MarkdownString(( localize(5560, "Getting chat ready..."))))
+                });
+                break;
             }
         }));
         let result = undefined;
@@ -363,41 +616,45 @@ let SetupAgent = class SetupAgent extends Disposable {
                 disableChatViewReveal: true,
                 forceAnonymous: this.chatEntitlementService.anonymous ? ChatSetupAnonymous.EnabledWithoutDialog : undefined
             });
-        }
-        catch (error) {
+        } catch (error) {
             this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
-        }
-        finally {
+        } finally {
             setupListener.dispose();
         }
-        if (typeof result?.success === 'boolean') {
+        if (typeof result?.success === "boolean") {
             if (result.success) {
                 if (result.dialogSkipped) {
                     await widget?.clear();
-                }
-                else if (requestModel) {
+                } else if (requestModel) {
                     let newRequest = this.replaceAgentInRequestModel(requestModel, chatAgentService);
                     newRequest = this.replaceToolInRequestModel(newRequest);
-                    await this.forwardRequestToChat(newRequest, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+                    await this.forwardRequestToChat(
+                        newRequest,
+                        progress,
+                        chatService,
+                        languageModelsService,
+                        chatAgentService,
+                        chatWidgetService,
+                        languageModelToolsService
+                    );
                 }
-            }
-            else {
+            } else {
                 progress({
-                    kind: 'warning',
-                    content: ( new MarkdownString(( localize(5368, "Chat setup failed."))))
+                    kind: "warning",
+                    content: ( new MarkdownString(( localize(5561, "Chat setup failed."))))
                 });
             }
         }
         else {
             progress({
-                kind: 'markdownContent',
+                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);
+        const agentPart = requestModel.message.parts.find(r => r instanceof ChatRequestAgentPart);
         if (!agentPart) {
             return requestModel;
         }
@@ -425,11 +682,11 @@ let SetupAgent = class SetupAgent extends Disposable {
             confirmation: requestModel.confirmation,
             locationData: requestModel.locationData,
             attachedContext: requestModel.attachedContext,
-            isCompleteAddedRequest: requestModel.isCompleteAddedRequest,
+            isCompleteAddedRequest: requestModel.isCompleteAddedRequest
         }));
     }
     replaceToolInRequestModel(requestModel) {
-        const toolPart = requestModel.message.parts.find((r) => r instanceof ChatRequestToolPart);
+        const toolPart = requestModel.message.parts.find(r => r instanceof ChatRequestToolPart);
         if (!toolPart) {
             return requestModel;
         }
@@ -444,9 +701,9 @@ let SetupAgent = class SetupAgent extends Disposable {
         ));
         const chatRequestToolEntry = {
             id: toolId,
-            name: 'new',
+            name: "new",
             range: toolPart.range,
-            kind: 'tool',
+            kind: "tool",
             value: undefined
         };
         const variableData = {
@@ -470,19 +727,11 @@ let SetupAgent = class SetupAgent extends Disposable {
             confirmation: requestModel.confirmation,
             locationData: requestModel.locationData,
             attachedContext: [chatRequestToolEntry],
-            isCompleteAddedRequest: requestModel.isCompleteAddedRequest,
+            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));
+SetupAgent = SetupAgent_1 = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, ILogService)), ( __param(5, ITelemetryService)), ( __param(6, IWorkbenchEnvironmentService)), ( __param(7, IWorkspaceTrustManagementService)), ( __param(8, IChatEntitlementService)), ( __param(9, IViewsService))], SetupAgent));
 class SetupTool {
     static registerTool(instantiationService, toolData) {
         return instantiationService.invokeFunction(accessor => {
@@ -493,12 +742,10 @@ class SetupTool {
     }
     async invoke(invocation, countTokens, progress, token) {
         const result = {
-            content: [
-                {
-                    kind: 'text',
-                    value: ''
-                }
-            ]
+            content: [{
+                kind: "text",
+                value: ""
+            }]
         };
         return result;
     }
@@ -511,7 +758,7 @@ let AINewSymbolNamesProvider = AINewSymbolNamesProvider_1 = class AINewSymbolNam
         return instantiationService.invokeFunction(accessor => {
             const languageFeaturesService = accessor.get(ILanguageFeaturesService);
             const provider = instantiationService.createInstance(AINewSymbolNamesProvider_1, context, controller);
-            return languageFeaturesService.newSymbolNamesProvider.register('*', provider);
+            return languageFeaturesService.newSymbolNamesProvider.register("*", provider);
         });
     }
     constructor(context, controller, instantiationService, chatEntitlementService) {
@@ -529,16 +776,13 @@ let AINewSymbolNamesProvider = AINewSymbolNamesProvider_1 = class AINewSymbolNam
         return [];
     }
 };
-AINewSymbolNamesProvider = AINewSymbolNamesProvider_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IChatEntitlementService))
-], AINewSymbolNamesProvider));
+AINewSymbolNamesProvider = AINewSymbolNamesProvider_1 = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IChatEntitlementService))], AINewSymbolNamesProvider));
 let ChatCodeActionsProvider = ChatCodeActionsProvider_1 = class ChatCodeActionsProvider {
     static registerProvider(instantiationService) {
         return instantiationService.invokeFunction(accessor => {
             const languageFeaturesService = accessor.get(ILanguageFeaturesService);
             const provider = instantiationService.createInstance(ChatCodeActionsProvider_1);
-            return languageFeaturesService.codeActionProvider.register('*', provider);
+            return languageFeaturesService.codeActionProvider.register("*", provider);
         });
     }
     constructor(markerService) {
@@ -551,81 +795,77 @@ let ChatCodeActionsProvider = ChatCodeActionsProvider_1 = class ChatCodeActionsP
         if (range.isEmpty()) {
             const textAtLine = model.getLineContent(range.startLineNumber);
             if (/^\s*$/.test(textAtLine)) {
-                generateOrModifyTitle = ( localize(5369, "Generate"));
+                generateOrModifyTitle = ( localize(5562, "Generate"));
                 generateOrModifyCommand = AICodeActionsHelper.generate(range);
             }
-        }
-        else {
+        } else {
             const textInSelection = model.getValueInRange(range);
             if (!/^\s*$/.test(textInSelection)) {
-                generateOrModifyTitle = ( localize(5370, "Modify"));
+                generateOrModifyTitle = ( localize(5563, "Modify"));
                 generateOrModifyCommand = AICodeActionsHelper.modify(range);
             }
         }
         if (generateOrModifyTitle && generateOrModifyCommand) {
             actions.push({
-                kind: CodeActionKind.RefactorRewrite.append('copilot').value,
+                kind: CodeActionKind.RefactorRewrite.append("copilot").value,
                 isAI: true,
                 title: generateOrModifyTitle,
-                command: generateOrModifyCommand,
+                command: generateOrModifyCommand
             });
         }
         const markers = AICodeActionsHelper.warningOrErrorMarkersAtRange(this.markerService, model.uri, range);
         if (markers.length > 0) {
             actions.push({
-                kind: CodeActionKind.QuickFix.append('copilot').value,
+                kind: CodeActionKind.QuickFix.append("copilot").value,
                 isAI: true,
                 diagnostics: markers,
-                title: ( localize(5371, "Fix")),
+                title: ( localize(5564, "Fix")),
                 command: AICodeActionsHelper.fixMarkers(markers, range)
             });
             actions.push({
-                kind: CodeActionKind.QuickFix.append('explain').append('copilot').value,
+                kind: CodeActionKind.QuickFix.append("explain").append("copilot").value,
                 isAI: true,
                 diagnostics: markers,
-                title: ( localize(5372, "Explain")),
+                title: ( localize(5565, "Explain")),
                 command: AICodeActionsHelper.explainMarkers(markers)
             });
         }
         return {
             actions,
-            dispose() { }
+            dispose() {}
         };
     }
 };
-ChatCodeActionsProvider = ChatCodeActionsProvider_1 = ( __decorate([
-    ( __param(0, IMarkerService))
-], ChatCodeActionsProvider));
+ChatCodeActionsProvider = ChatCodeActionsProvider_1 = ( __decorate([( __param(0, IMarkerService))], ChatCodeActionsProvider));
 class AICodeActionsHelper {
     static warningOrErrorMarkersAtRange(markerService, resource, range) {
-        return markerService
-            .read({ resource, severities: MarkerSeverity.Error | MarkerSeverity.Warning })
-            .filter(marker => range.startLineNumber <= marker.endLineNumber && range.endLineNumber >= marker.startLineNumber);
+        return markerService.read({
+            resource,
+            severities: MarkerSeverity.Error | MarkerSeverity.Warning
+        }).filter(
+            marker => range.startLineNumber <= marker.endLineNumber && range.endLineNumber >= marker.startLineNumber
+        );
     }
     static modify(range) {
         return {
             id: ACTION_START,
-            title: ( localize(5370, "Modify")),
-            arguments: [
-                {
-                    initialSelection: this.rangeToSelection(range),
-                    initialRange: range,
-                    position: range.getStartPosition()
-                }
-            ]
+            title: ( localize(5563, "Modify")),
+            arguments: [{
+                initialSelection: this.rangeToSelection(range),
+                initialRange: range,
+                position: range.getStartPosition()
+            }]
         };
     }
     static generate(range) {
         return {
             id: ACTION_START,
-            title: ( localize(5369, "Generate")),
-            arguments: [
-                {
-                    initialSelection: this.rangeToSelection(range),
-                    initialRange: range,
-                    position: range.getStartPosition()
-                }
-            ]
+            title: ( localize(5562, "Generate")),
+            arguments: [{
+                initialSelection: this.rangeToSelection(range),
+                initialRange: range,
+                position: range.getStartPosition()
+            }]
         };
     }
     static rangeToSelection(range) {
@@ -639,27 +879,23 @@ class AICodeActionsHelper {
     static explainMarkers(markers) {
         return {
             id: CHAT_OPEN_ACTION_ID,
-            title: ( localize(5372, "Explain")),
-            arguments: [
-                {
-                    query: `@workspace /explain ${( markers.map(marker => marker.message)).join(', ')}`,
-                    isPartialQuery: true
-                }
-            ]
+            title: ( localize(5565, "Explain")),
+            arguments: [{
+                query: `@workspace /explain ${( markers.map(marker => marker.message)).join(", ")}`,
+                isPartialQuery: true
+            }]
         };
     }
     static fixMarkers(markers, range) {
         return {
             id: ACTION_START,
-            title: ( localize(5371, "Fix")),
-            arguments: [
-                {
-                    message: `/fix ${( markers.map(marker => marker.message)).join(', ')}`,
-                    initialSelection: this.rangeToSelection(range),
-                    initialRange: range,
-                    position: range.getStartPosition()
-                }
-            ]
+            title: ( localize(5564, "Fix")),
+            arguments: [{
+                message: `/fix ${( markers.map(marker => marker.message)).join(", ")}`,
+                initialSelection: this.rangeToSelection(range),
+                initialRange: range,
+                position: range.getStartPosition()
+            }]
         };
     }
 }