@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -2,16 +2,21 @@
 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 { reserveWindowForExternalOpen, getWindow, $, releaseReservedWindowForExternalOpen } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { isMobileStandalone, isSafari } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/browser';
 import { Dialog, DialogContentsAlignment } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dialog/dialog';
-import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 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 { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ChatMicrosoftAuthenticationEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/chatSettings';
 import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { createWorkbenchDialogOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/dialogs/dialog';
+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';
@@ -19,10 +24,10 @@ import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/com
 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 { IWorkspaceTrustRequestService, IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
-import { isProUser, ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+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 { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { ChatSetupStrategy, ChatSetupAnonymous } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatSetup/chatSetup';
+import { ChatSetupStrategy, ChatSetupDialogVisibleContext, ChatSetupAnonymous, ChatSetupError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatSetup/chatSetup';
 import { GitHubPaths } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount';
 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';
@@ -32,26 +37,206 @@ import { raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 
 var ChatSetup_1;
 registerCss(chatSetup);
+const fallbackProviders = {
+    default: {
+        id: "",
+        name: ""
+    },
+    enterprise: {
+        id: "",
+        name: ""
+    },
+    apple: {
+        id: "",
+        name: ""
+    },
+    google: {
+        id: "",
+        name: ""
+    },
+    microsoft: {
+        id: "",
+        name: ""
+    }
+};
+const configuredProviders = product.defaultChatAgent?.provider;
 const defaultChat = {
     chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? "",
     publicCodeMatchesUrl: product.defaultChatAgent?.publicCodeMatchesUrl ?? "",
-    provider: product.defaultChatAgent?.provider ?? {
-        default: {
-            name: ""
-        },
-        enterprise: {
-            name: ""
-        },
-        apple: {
-            name: ""
-        },
-        google: {
-            name: ""
-        }
+    provider: {
+        default: configuredProviders?.default ?? fallbackProviders.default,
+        enterprise: configuredProviders?.enterprise ?? fallbackProviders.enterprise,
+        apple: configuredProviders?.apple ?? fallbackProviders.apple,
+        google: configuredProviders?.google ?? fallbackProviders.google,
+        microsoft: configuredProviders?.microsoft ?? fallbackProviders.microsoft
     },
     termsStatementUrl: product.defaultChatAgent?.termsStatementUrl ?? "",
     privacyStatementUrl: product.defaultChatAgent?.privacyStatementUrl ?? ""
 };
+function entersProviderAuthentication(strategy) {
+    switch (strategy) {
+    case ChatSetupStrategy.SetupWithEnterpriseProvider:
+    case ChatSetupStrategy.SetupWithoutEnterpriseProvider:
+    case ChatSetupStrategy.SetupWithGoogleProvider:
+    case ChatSetupStrategy.SetupWithAppleProvider:
+    case ChatSetupStrategy.SetupWithMicrosoftProvider:
+        return true;
+    default:
+        return false;
+    }
+}
+let ChatSetupDialog = class ChatSetupDialog extends Disposable {
+    constructor(
+        container,
+        options,
+        keybindingService,
+        layoutService,
+        hostService,
+        markdownRendererService,
+        contextKeyService
+    ) {
+        super();
+        this.options = options;
+        const dialogVisible = ChatSetupDialogVisibleContext.bindTo(contextKeyService);
+        dialogVisible.set(true);
+        this._register(toDisposable(() => dialogVisible.reset()));
+        this.dialog = this._register(( new Dialog(container, options.title, ( options.buttons.map(button => button.label)), createWorkbenchDialogOptions({
+            type: "none",
+            extraClasses: ["chat-setup-dialog", ...(options.extraClasses ?? [])],
+            detail: " ",
+            icon: options.icon,
+            alignment: DialogContentsAlignment.Vertical,
+            cancelId: options.buttons.length,
+            disableCloseButton: options.disableCloseButton,
+            renderFooter: footer => {
+                const element = footer.appendChild($(".chat-setup-dialog-footer"));
+                const renderedFooter = this._register(markdownRendererService.render(( new MarkdownString(options.footer, {
+                    isTrusted: true
+                }))));
+                element.appendChild($("p", undefined, renderedFooter.element));
+                const customFooter = options.renderFooter?.(element);
+                if (customFooter) {
+                    this._register(customFooter);
+                }
+            },
+            buttonOptions: ( options.buttons.map(button => {
+                const classes = button.classes;
+                const opensBrowser = (isMobileStandalone() || isSafari) && entersProviderAuthentication(button.strategy);
+                if (!classes && !opensBrowser) {
+                    return undefined;
+                }
+                return {
+                    styleButton: control => {
+                        if (classes?.length) {
+                            control.element.classList.add(...classes);
+                        }
+                        if (opensBrowser) {
+                            this._register(control.onDidClick(
+                                () => reserveWindowForExternalOpen(getWindow(control.element), ( localize(8511, "Signing in…")))
+                            ));
+                        }
+                    }
+                };
+            }))
+        }, keybindingService, layoutService, hostService))));
+    }
+    async show() {
+        const {
+            button
+        } = await this.dialog.show();
+        return this.options.buttons[button]?.strategy ?? ChatSetupStrategy.Canceled;
+    }
+};
+ChatSetupDialog = ( __decorate([( __param(2, IKeybindingService)), ( __param(3, ILayoutService)), ( __param(4, IHostService)), ( __param(5, IMarkdownRendererService)), ( __param(6, IContextKeyService))], ChatSetupDialog));
+async function showChatSetupDialogWithCancellation(dialog, cancellationToken, onDidDismissDialog) {
+    let canceled = false;
+    const cancellationListener = cancellationToken?.onCancellationRequested(() => {
+        canceled = true;
+        dialog.dispose();
+    });
+    try {
+        if (cancellationToken?.isCancellationRequested) {
+            canceled = true;
+            dialog.dispose();
+        }
+        const strategy = canceled ? ChatSetupStrategy.Canceled : await dialog.show();
+        if (!canceled && strategy === ChatSetupStrategy.Canceled) {
+            onDidDismissDialog?.();
+        }
+        return strategy;
+    } finally {
+        cancellationListener?.dispose();
+        dialog.dispose();
+    }
+}
+function shouldShowMicrosoftProvider(configurationService) {
+    return configurationService.getValue(ChatMicrosoftAuthenticationEnabledSettingId) === true;
+}
+function getChatSetupDialogButtons(
+    entitlement,
+    options,
+    enterpriseAuthentication,
+    showMicrosoftProvider,
+    providers = defaultChat.provider
+) {
+    const button = (label, strategy, ...classes) => ({
+        label,
+        strategy,
+        classes
+    });
+    if (!options?.forceAnonymous && (entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog)) {
+        const defaultProviderButton = button(( localize(8512, "Continue with {0}", providers.default.name)), ChatSetupStrategy.SetupWithoutEnterpriseProvider, "continue-button", "default");
+        const defaultProviderLink = button(defaultProviderButton.label, defaultProviderButton.strategy, "link-button");
+        const enterpriseProviderButton = button(( localize(8512, "Continue with {0}", providers.enterprise.name)), ChatSetupStrategy.SetupWithEnterpriseProvider, "continue-button", "default");
+        const enterpriseProviderLink = button(
+            enterpriseProviderButton.label,
+            enterpriseProviderButton.strategy,
+            "link-button"
+        );
+        const googleProviderButton = button(( localize(8512, "Continue with {0}", providers.google.name)), ChatSetupStrategy.SetupWithGoogleProvider, "continue-button", "google");
+        const appleProviderButton = button(( localize(8512, "Continue with {0}", providers.apple.name)), ChatSetupStrategy.SetupWithAppleProvider, "continue-button", "apple");
+        const microsoftProviderButton = button(( localize(8512, "Continue with {0}", providers.microsoft.name)), ChatSetupStrategy.SetupWithMicrosoftProvider, "continue-button", "microsoft");
+        const socialProviderButtons = [
+            googleProviderButton,
+            appleProviderButton,
+            ...(showMicrosoftProvider ? [microsoftProviderButton] : [])
+        ];
+        const providerButtons = enterpriseAuthentication ? [enterpriseProviderButton, ...socialProviderButtons, defaultProviderLink] : [defaultProviderButton, ...socialProviderButtons, enterpriseProviderLink];
+        return options?.allowContinueWithoutSignIn ? [...providerButtons, button(( localize(8513, "Continue Without Signing In")), ChatSetupStrategy.Canceled, "link-button")] : providerButtons;
+    }
+    return [button(( localize(8514, "Use AI Features")), ChatSetupStrategy.DefaultSetup)];
+}
+function getChatSetupDialogFooter(
+    forceAnonymous,
+    telemetryLevel,
+    settingsUrl,
+    content = {
+        providerName: defaultChat.provider.default.name,
+        termsStatementUrl: defaultChat.termsStatementUrl,
+        privacyStatementUrl: defaultChat.privacyStatementUrl,
+        publicCodeMatchesUrl: defaultChat.publicCodeMatchesUrl
+    }
+) {
+    if (forceAnonymous || telemetryLevel === TelemetryLevel.NONE) {
+        return localize(
+            8515,
+            "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}).",
+            content.providerName,
+            content.termsStatementUrl,
+            content.privacyStatementUrl
+        );
+    }
+    return localize(
+        8516,
+        "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.",
+        content.providerName,
+        content.termsStatementUrl,
+        content.privacyStatementUrl,
+        content.providerName,
+        content.publicCodeMatchesUrl,
+        settingsUrl
+    );
+}
 let ChatSetup = class ChatSetup {
     static {
         ChatSetup_1 = this;
@@ -71,31 +256,29 @@ let ChatSetup = class ChatSetup {
         controller,
         telemetryService,
         layoutService,
-        keybindingService,
         chatEntitlementService,
         logService,
         widgetService,
         workspaceTrustRequestService,
-        markdownRendererService,
         defaultAccountService,
-        hostService,
         extensionService,
-        workspaceTrustManagementService
+        workspaceTrustManagementService,
+        instantiationService,
+        configurationService
     ) {
         this.context = context;
         this.controller = controller;
         this.telemetryService = telemetryService;
         this.layoutService = layoutService;
-        this.keybindingService = keybindingService;
         this.chatEntitlementService = chatEntitlementService;
         this.logService = logService;
         this.widgetService = widgetService;
         this.workspaceTrustRequestService = workspaceTrustRequestService;
-        this.markdownRendererService = markdownRendererService;
         this.defaultAccountService = defaultAccountService;
-        this.hostService = hostService;
         this.extensionService = extensionService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
         this.pendingRun = undefined;
         this.skipDialogOnce = false;
     }
@@ -119,9 +302,15 @@ let ChatSetup = class ChatSetup {
         });
         const dialogSkipped = this.skipDialogOnce;
         this.skipDialogOnce = false;
+        if (options?.cancellationToken?.isCancellationRequested) {
+            return {
+                dialogSkipped,
+                success: undefined
+            };
+        }
         const wasTrusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
         const trusted = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localize(7282, "AI features are currently only supported in trusted workspaces."))
+            message: ( localize(8517, "AI features are currently only supported in trusted workspaces."))
         });
         if (!trusted) {
             this.context.update({
@@ -138,6 +327,12 @@ let ChatSetup = class ChatSetup {
                 success: undefined
             };
         }
+        if (options?.cancellationToken?.isCancellationRequested) {
+            return {
+                dialogSkipped,
+                success: undefined
+            };
+        }
         if (!wasTrusted) {
             await this.whenChatExtensionActivated();
         }
@@ -154,21 +349,25 @@ let ChatSetup = class ChatSetup {
         if (setupStrategy === ChatSetupStrategy.DefaultSetup && this.defaultAccountService.getDefaultAccountAuthenticationProvider().enterprise) {
             setupStrategy = ChatSetupStrategy.SetupWithEnterpriseProvider;
         }
-        if (setupStrategy !== ChatSetupStrategy.Canceled) {
-            options?.onSignInStarted?.();
-        }
-        if (setupStrategy !== ChatSetupStrategy.Canceled && !options?.disableChatViewReveal) {
-            this.widgetService.revealWidget();
-        }
         let success = undefined;
+        let setupError;
+        let errorAlreadyHandled = false;
+        const setupCancellation = ( new CancellationTokenSource(options?.cancellationToken));
         try {
+            if (setupStrategy !== ChatSetupStrategy.Canceled) {
+                options?.onSignInStarted?.(() => setupCancellation.cancel());
+            }
+            if (setupStrategy !== ChatSetupStrategy.Canceled && !options?.disableChatViewReveal) {
+                this.widgetService.revealWidget();
+            }
             switch (setupStrategy) {
             case ChatSetupStrategy.SetupWithEnterpriseProvider:
                 success = await this.controller.value.setupWithProvider({
                     useEnterpriseProvider: true,
                     useSocialProvider: undefined,
                     additionalScopes: options?.additionalScopes,
-                    forceAnonymous: options?.forceAnonymous
+                    forceAnonymous: options?.forceAnonymous,
+                    cancellationToken: setupCancellation.token
                 });
                 break;
             case ChatSetupStrategy.SetupWithoutEnterpriseProvider:
@@ -176,7 +375,8 @@ let ChatSetup = class ChatSetup {
                     useEnterpriseProvider: false,
                     useSocialProvider: undefined,
                     additionalScopes: options?.additionalScopes,
-                    forceAnonymous: options?.forceAnonymous
+                    forceAnonymous: options?.forceAnonymous,
+                    cancellationToken: setupCancellation.token
                 });
                 break;
             case ChatSetupStrategy.SetupWithAppleProvider:
@@ -184,7 +384,8 @@ let ChatSetup = class ChatSetup {
                     useEnterpriseProvider: false,
                     useSocialProvider: "apple",
                     additionalScopes: options?.additionalScopes,
-                    forceAnonymous: options?.forceAnonymous
+                    forceAnonymous: options?.forceAnonymous,
+                    cancellationToken: setupCancellation.token
                 });
                 break;
             case ChatSetupStrategy.SetupWithGoogleProvider:
@@ -192,13 +393,24 @@ let ChatSetup = class ChatSetup {
                     useEnterpriseProvider: false,
                     useSocialProvider: "google",
                     additionalScopes: options?.additionalScopes,
-                    forceAnonymous: options?.forceAnonymous
+                    forceAnonymous: options?.forceAnonymous,
+                    cancellationToken: setupCancellation.token
+                });
+                break;
+            case ChatSetupStrategy.SetupWithMicrosoftProvider:
+                success = await this.controller.value.setupWithProvider({
+                    useEnterpriseProvider: false,
+                    useSocialProvider: "microsoft",
+                    additionalScopes: options?.additionalScopes,
+                    forceAnonymous: options?.forceAnonymous,
+                    cancellationToken: setupCancellation.token
                 });
                 break;
             case ChatSetupStrategy.DefaultSetup:
                 success = await this.controller.value.setup({
                     ...options,
-                    forceAnonymous: options?.forceAnonymous
+                    forceAnonymous: options?.forceAnonymous,
+                    cancellationToken: setupCancellation.token
                 });
                 break;
             case ChatSetupStrategy.Canceled:
@@ -216,6 +428,15 @@ let ChatSetup = class ChatSetup {
         } catch (error) {
             this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
             success = false;
+            if (error instanceof ChatSetupError) {
+                setupError = error.originalError;
+                errorAlreadyHandled = error.userNotified;
+            } else {
+                setupError = error instanceof Error ? error : ( new Error(toErrorMessage(error)));
+            }
+        } finally {
+            setupCancellation.dispose();
+            releaseReservedWindowForExternalOpen(( localize(8518, "Sign-in did not complete. You can close this window.")));
         }
         if (success) {
             this.context.update({
@@ -224,7 +445,9 @@ let ChatSetup = class ChatSetup {
         }
         return {
             success,
-            dialogSkipped
+            dialogSkipped,
+            error: setupError,
+            errorAlreadyHandled
         };
     }
     isChatExtensionActivated() {
@@ -256,69 +479,31 @@ let ChatSetup = class ChatSetup {
         }
     }
     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: options?.dialogIcon ?? Codicon.copilotLarge,
-                alignment: DialogContentsAlignment.Vertical,
-                cancelId: buttons.length,
-                disableCloseButton: options?.disableCloseButton ?? false,
-                renderFooter: footer => footer.appendChild(this.createDialogFooter(disposables, options)),
-                buttonOptions: ( buttons.map(button => button[2]))
-            }, this.keybindingService, this.layoutService, this.hostService)
-        )));
-        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(7283, "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(7283, "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(7283, "Continue with {0}", defaultChat.provider.google.name)), ChatSetupStrategy.SetupWithGoogleProvider, styleButton("continue-button", "google")];
-            const appleProviderButton = [( localize(7283, "Continue with {0}", defaultChat.provider.apple.name)), ChatSetupStrategy.SetupWithAppleProvider, styleButton("continue-button", "apple")];
-            if (!this.defaultAccountService.getDefaultAccountAuthenticationProvider().enterprise) {
-                buttons = coalesce([
-                    defaultProviderButton,
-                    googleProviderButton,
-                    appleProviderButton,
-                    enterpriseProviderLink
-                ]);
-            } else {
-                buttons = coalesce([
-                    enterpriseProviderButton,
-                    googleProviderButton,
-                    appleProviderButton,
-                    defaultProviderLink
-                ]);
-            }
-        } else {
-            buttons = [[( localize(7284, "Use AI Features")), ChatSetupStrategy.DefaultSetup, undefined]];
+        if (options?.cancellationToken?.isCancellationRequested) {
+            return ChatSetupStrategy.Canceled;
         }
-        return buttons;
+        const enterpriseAuthentication = this.defaultAccountService.getDefaultAccountAuthenticationProvider().enterprise;
+        const showMicrosoftProvider = shouldShowMicrosoftProvider(this.configurationService);
+        const buttons = getChatSetupDialogButtons(
+            this.context.state.entitlement,
+            options,
+            enterpriseAuthentication,
+            showMicrosoftProvider
+        );
+        const dialog = this.instantiationService.createInstance(ChatSetupDialog, this.layoutService.activeContainer, {
+            title: this.getDialogTitle(options),
+            buttons,
+            icon: options?.dialogIcon ?? Codicon.copilotLarge,
+            disableCloseButton: options?.disableCloseButton ?? false,
+            footer: getChatSetupDialogFooter(
+                options?.forceAnonymous,
+                this.telemetryService.telemetryLevel,
+                this.defaultAccountService.resolveGitHubUrl(GitHubPaths.copilotSettings)
+            ),
+            extraClasses: options?.dialogExtraClasses,
+            renderFooter: options?.renderDialogFooter
+        });
+        return showChatSetupDialogWithCancellation(dialog, options?.cancellationToken, options?.onDidDismissDialog);
     }
     getDialogTitle(options) {
         if (options?.dialogTitle) {
@@ -326,49 +511,17 @@ let ChatSetup = class ChatSetup {
         }
         if (this.chatEntitlementService.anonymous) {
             if (options?.forceAnonymous) {
-                return localize(7285, "Start using AI Features");
+                return localize(8519, "Start using AI Features");
             } else {
-                return localize(7286, "Enable more AI features");
+                return localize(8520, "Enable more AI features");
             }
         }
         if (this.context.state.entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog) {
-            return localize(7287, "Sign in to use GitHub Copilot");
-        }
-        return localize(7285, "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(
-                7288,
-                "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}).",
-                defaultChat.provider.default.name,
-                defaultChat.termsStatementUrl,
-                defaultChat.privacyStatementUrl
-            ));
-        } else {
-            footer = ( localize(
-                7289,
-                "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,
-                this.defaultAccountService.resolveGitHubUrl(GitHubPaths.copilotSettings)
-            ));
+            return localize(8521, "Sign in to use GitHub Copilot");
         }
-        element.appendChild($(
-            "p",
-            undefined,
-            disposables.add(this.markdownRendererService.render(( new MarkdownString(footer, {
-                isTrusted: true
-            })))).element
-        ));
-        return element;
+        return localize(8519, "Start using AI Features");
     }
 };
-ChatSetup = ChatSetup_1 = ( __decorate([( __param(2, ITelemetryService)), ( __param(3, ILayoutService)), ( __param(4, IKeybindingService)), ( __param(5, IChatEntitlementService)), ( __param(6, ILogService)), ( __param(7, IChatWidgetService)), ( __param(8, IWorkspaceTrustRequestService)), ( __param(9, IMarkdownRendererService)), ( __param(10, IDefaultAccountService)), ( __param(11, IHostService)), ( __param(12, IExtensionService)), ( __param(13, IWorkspaceTrustManagementService))], ChatSetup));
+ChatSetup = ChatSetup_1 = ( __decorate([( __param(2, ITelemetryService)), ( __param(3, ILayoutService)), ( __param(4, IChatEntitlementService)), ( __param(5, ILogService)), ( __param(6, IChatWidgetService)), ( __param(7, IWorkspaceTrustRequestService)), ( __param(8, IDefaultAccountService)), ( __param(9, IExtensionService)), ( __param(10, IWorkspaceTrustManagementService)), ( __param(11, IInstantiationService)), ( __param(12, IConfigurationService))], ChatSetup));
 
-export { ChatSetup };
+export { ChatSetup, ChatSetupDialog, getChatSetupDialogButtons, getChatSetupDialogFooter, shouldShowMicrosoftProvider, showChatSetupDialogWithCancellation };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/media/chatSetup.css

@@ -59,3 +59,12 @@
 .chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.apple::before {
 	background-image: url('./apple-dark.svg');
 }
+
+.monaco-workbench.hc-light .chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.microsoft::before,
+.monaco-workbench.vs .chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.microsoft::before {
+	background-image: url('./microsoft-light.svg');
+}
+
+.chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.microsoft::before {
+	background-image: url('./microsoft-dark.svg');
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/media/microsoft-dark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" fill="white"><path d="M7.5 1.5H1.5V7.5H7.5V1.5Z"/><path d="M14.5 1.5H8.5V7.5H14.5V1.5Z"/><path d="M14.5 8.5H8.5V14.5H14.5V8.5Z"/><path d="M7.5 8.5H1.5V14.5H7.5V8.5Z"/></svg>

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/media/microsoft-light.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" fill="black"><path d="M7.5 1.5H1.5V7.5H7.5V1.5Z"/><path d="M14.5 1.5H8.5V7.5H14.5V1.5Z"/><path d="M14.5 8.5H8.5V14.5H14.5V8.5Z"/><path d="M7.5 8.5H1.5V14.5H7.5V8.5Z"/></svg>

package/vscode/src/vs/workbench/contrib/chat/browser/chatSideChat.d.ts

@@ -0,0 +1,9 @@
+import { IChatSideChatSelection } from "../common/chatSideChatService.js";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+/**
+ * Captures the user's current text selection within `widget`'s transcript so a
+ * side chat can be anchored to it. Returns `undefined` when there is no
+ * meaningful selection, when it falls outside the widget, or when it lives in
+ * the input editor (which holds the question being asked, not the source text).
+ */
+export declare function captureSideChatSelection(widget: IChatWidget | undefined): IChatSideChatSelection | undefined;

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

@@ -0,0 +1,24 @@
+
+import { getActiveWindow, isAncestor } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+
+function captureSideChatSelection(widget) {
+    if (!widget) {
+        return undefined;
+    }
+    const nativeSelection = getActiveWindow().getSelection();
+    const selectedText = nativeSelection?.toString();
+    if (!nativeSelection || !selectedText || !selectedText.trim()) {
+        return undefined;
+    }
+    const { anchorNode, focusNode } = nativeSelection;
+    if (!anchorNode || !focusNode || !isAncestor(anchorNode, widget.domNode) || !isAncestor(focusNode, widget.domNode)) {
+        return undefined;
+    }
+    const inputEditorDomNode = widget.inputEditor.getDomNode();
+    if (inputEditorDomNode && (isAncestor(anchorNode, inputEditorDomNode) || isAncestor(focusNode, inputEditorDomNode))) {
+        return undefined;
+    }
+    return { text: selectedText };
+}
+
+export { captureSideChatSelection };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSlashCommands.d.ts

@@ -14,10 +14,11 @@ import { IAgentHostSessionWorkingDirectoryResolver } from "@codingame/monaco-vsc
 import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
 import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IChatPetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatPetService.service";
 export declare class ChatSlashCommandsContribution extends Disposable {
     private readonly environmentService;
     static readonly ID = "workbench.contrib.chatSlashCommands";
-    constructor(slashCommandService: IChatSlashCommandService, commandService: ICommandService, chatAgentService: IChatAgentService, instantiationService: IInstantiationService, agentSessionsService: IAgentSessionsService, chatService: IChatService, configurationService: IConfigurationService, chatWidgetService: IChatWidgetService, agentHostService: IAgentHostService, agentHostProvisionalService: IAgentHostUntitledProvisionalSessionService, agentHostWorkingDirectoryResolver: IAgentHostSessionWorkingDirectoryResolver, workspaceContextService: IWorkspaceContextService, environmentService: IWorkbenchEnvironmentService);
+    constructor(slashCommandService: IChatSlashCommandService, commandService: ICommandService, chatAgentService: IChatAgentService, instantiationService: IInstantiationService, agentSessionsService: IAgentSessionsService, chatService: IChatService, configurationService: IConfigurationService, chatWidgetService: IChatWidgetService, agentHostService: IAgentHostService, agentHostProvisionalService: IAgentHostUntitledProvisionalSessionService, agentHostWorkingDirectoryResolver: IAgentHostSessionWorkingDirectoryResolver, workspaceContextService: IWorkspaceContextService, chatPetService: IChatPetService, environmentService: IWorkbenchEnvironmentService);
 }
 /**
  * Registers slash commands declared by chat session providers via