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

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

@@ -0,0 +1,37 @@
+import { Lazy } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lazy";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ChatEntitlementContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService";
+import { ChatSetupController } from "./chatSetupController.js";
+import { IChatSetupResult, ChatSetupAnonymous } from "./chatSetup.js";
+export declare class ChatSetup {
+    private readonly context;
+    private readonly controller;
+    private readonly telemetryService;
+    private readonly layoutService;
+    private readonly keybindingService;
+    private readonly chatEntitlementService;
+    private readonly logService;
+    private readonly configurationService;
+    private readonly widgetService;
+    private readonly workspaceTrustRequestService;
+    private readonly markdownRendererService;
+    private static instance;
+    static getInstance(instantiationService: IInstantiationService, context: ChatEntitlementContext, controller: Lazy<ChatSetupController>): ChatSetup;
+    private pendingRun;
+    private skipDialogOnce;
+    private constructor();
+    skipDialog(): void;
+    run(options?: {
+        disableChatViewReveal?: boolean;
+        forceSignInDialog?: boolean;
+        additionalScopes?: readonly string[];
+        forceAnonymous?: ChatSetupAnonymous;
+    }): Promise<IChatSetupResult>;
+    private doRun;
+    private showDialog;
+    private getButtons;
+    private getDialogTitle;
+    private createDialogFooter;
+}
+export declare function refreshTokens(commandService: ICommandService): void;

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

@@ -0,0 +1,260 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatSetup from './media/chatSetup.css';
+import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Dialog, DialogContentsAlignment } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dialog/dialog';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+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 { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { createWorkbenchDialogOptions } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/browser/dialog';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+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 } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { isProUser, ChatEntitlement, ChatEntitlementRequests } 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 './chatSetup.js';
+
+var ChatSetup_1;
+registerCss(chatSetup);
+const defaultChat = {
+    publicCodeMatchesUrl: product.defaultChatAgent?.publicCodeMatchesUrl ?? '',
+    provider: product.defaultChatAgent?.provider ?? { default: { name: '' }, enterprise: { id: '', name: '' }, apple: { name: '' }, google: { name: '' } },
+    manageSettingsUrl: product.defaultChatAgent?.manageSettingsUrl ?? '',
+    termsStatementUrl: product.defaultChatAgent?.termsStatementUrl ?? '',
+    privacyStatementUrl: product.defaultChatAgent?.privacyStatementUrl ?? ''
+};
+let ChatSetup = class ChatSetup {
+    static { ChatSetup_1 = this; }
+    static { this.instance = undefined; }
+    static getInstance(instantiationService, context, controller) {
+        let instance = ChatSetup_1.instance;
+        if (!instance) {
+            instance = ChatSetup_1.instance = instantiationService.invokeFunction(accessor => {
+                return ( new ChatSetup_1(
+                    context,
+                    controller,
+                    accessor.get(ITelemetryService),
+                    accessor.get(IWorkbenchLayoutService),
+                    accessor.get(IKeybindingService),
+                    accessor.get(IChatEntitlementService),
+                    accessor.get(ILogService),
+                    accessor.get(IConfigurationService),
+                    accessor.get(IChatWidgetService),
+                    accessor.get(IWorkspaceTrustRequestService),
+                    accessor.get(IMarkdownRendererService)
+                ));
+            });
+        }
+        return instance;
+    }
+    constructor(context, controller, telemetryService, layoutService, keybindingService, chatEntitlementService, logService, configurationService, widgetService, workspaceTrustRequestService, markdownRendererService) {
+        this.context = context;
+        this.controller = controller;
+        this.telemetryService = telemetryService;
+        this.layoutService = layoutService;
+        this.keybindingService = keybindingService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.widgetService = widgetService;
+        this.workspaceTrustRequestService = workspaceTrustRequestService;
+        this.markdownRendererService = markdownRendererService;
+        this.pendingRun = undefined;
+        this.skipDialogOnce = false;
+    }
+    skipDialog() {
+        this.skipDialogOnce = true;
+    }
+    async run(options) {
+        if (this.pendingRun) {
+            return this.pendingRun;
+        }
+        this.pendingRun = this.doRun(options);
+        try {
+            return await this.pendingRun;
+        }
+        finally {
+            this.pendingRun = undefined;
+        }
+    }
+    async doRun(options) {
+        this.context.update({ later: false });
+        const dialogSkipped = this.skipDialogOnce;
+        this.skipDialogOnce = false;
+        const trusted = await this.workspaceTrustRequestService.requestWorkspaceTrust({
+            message: ( localize(5564, "AI features are currently only supported in trusted workspaces."))
+        });
+        if (!trusted) {
+            this.context.update({ later: true });
+            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotTrusted', installDuration: 0, signUpErrorCode: undefined, provider: undefined });
+            return { dialogSkipped, success: undefined  };
+        }
+        let setupStrategy;
+        if (!options?.forceSignInDialog && (dialogSkipped || isProUser(this.chatEntitlementService.entitlement) || this.chatEntitlementService.entitlement === ChatEntitlement.Free)) {
+            setupStrategy = ChatSetupStrategy.DefaultSetup;
+        }
+        else if (options?.forceAnonymous === ChatSetupAnonymous.EnabledWithoutDialog) {
+            setupStrategy = ChatSetupStrategy.DefaultSetup;
+        }
+        else {
+            setupStrategy = await this.showDialog(options);
+        }
+        if (setupStrategy === ChatSetupStrategy.DefaultSetup && ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id) {
+            setupStrategy = ChatSetupStrategy.SetupWithEnterpriseProvider;
+        }
+        if (setupStrategy !== ChatSetupStrategy.Canceled && !options?.disableChatViewReveal) {
+            this.widgetService.revealWidget();
+        }
+        let success = undefined;
+        try {
+            switch (setupStrategy) {
+                case ChatSetupStrategy.SetupWithEnterpriseProvider:
+                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: true, useSocialProvider: undefined, additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
+                    break;
+                case ChatSetupStrategy.SetupWithoutEnterpriseProvider:
+                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: false, useSocialProvider: undefined, additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
+                    break;
+                case ChatSetupStrategy.SetupWithAppleProvider:
+                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: false, useSocialProvider: 'apple', additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
+                    break;
+                case ChatSetupStrategy.SetupWithGoogleProvider:
+                    success = await this.controller.value.setupWithProvider({ useEnterpriseProvider: false, useSocialProvider: 'google', additionalScopes: options?.additionalScopes, forceAnonymous: options?.forceAnonymous });
+                    break;
+                case ChatSetupStrategy.DefaultSetup:
+                    success = await this.controller.value.setup({ ...options, forceAnonymous: options?.forceAnonymous });
+                    break;
+                case ChatSetupStrategy.Canceled:
+                    this.context.update({ later: true });
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedMaybeLater', installDuration: 0, signUpErrorCode: undefined, provider: undefined });
+                    break;
+            }
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
+            success = false;
+        }
+        return { success, dialogSkipped };
+    }
+    async showDialog(options) {
+        const disposables = ( new DisposableStore());
+        const buttons = this.getButtons(options);
+        const dialog = disposables.add(( new Dialog(
+            this.layoutService.activeContainer,
+            this.getDialogTitle(options),
+            ( buttons.map(button => button[0])),
+            createWorkbenchDialogOptions({
+                type: 'none',
+                extraClasses: ['chat-setup-dialog'],
+                detail: ' ',
+                icon: Codicon.copilotLarge,
+                alignment: DialogContentsAlignment.Vertical,
+                cancelId: buttons.length - 1,
+                disableCloseButton: true,
+                renderFooter: footer => footer.appendChild(this.createDialogFooter(disposables, options)),
+                buttonOptions: ( buttons.map(button => button[2]))
+            }, this.keybindingService, this.layoutService)
+        )));
+        const { button } = await dialog.show();
+        disposables.dispose();
+        return buttons[button]?.[1] ?? ChatSetupStrategy.Canceled;
+    }
+    getButtons(options) {
+        const styleButton = (...classes) => ({ styleButton: (button) => button.element.classList.add(...classes) });
+        let buttons;
+        if (!options?.forceAnonymous && (this.context.state.entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog)) {
+            const defaultProviderButton = [( localize(5565, "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(5565, "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(5565, "Continue with {0}", defaultChat.provider.google.name)), ChatSetupStrategy.SetupWithGoogleProvider, styleButton('continue-button', 'google')];
+            const appleProviderButton = [( localize(5565, "Continue with {0}", defaultChat.provider.apple.name)), ChatSetupStrategy.SetupWithAppleProvider, styleButton('continue-button', 'apple')];
+            if (ChatEntitlementRequests.providerId(this.configurationService) !== defaultChat.provider.enterprise.id) {
+                buttons = coalesce([
+                    defaultProviderButton,
+                    googleProviderButton,
+                    appleProviderButton,
+                    enterpriseProviderLink
+                ]);
+            }
+            else {
+                buttons = coalesce([
+                    enterpriseProviderButton,
+                    googleProviderButton,
+                    appleProviderButton,
+                    defaultProviderLink
+                ]);
+            }
+        }
+        else {
+            buttons = [[( localize(5566, "Use AI Features")), ChatSetupStrategy.DefaultSetup, undefined]];
+        }
+        buttons.push([( localize(5567, "Skip for now")), ChatSetupStrategy.Canceled, styleButton('link-button', 'skip-button')]);
+        return buttons;
+    }
+    getDialogTitle(options) {
+        if (this.chatEntitlementService.anonymous) {
+            if (options?.forceAnonymous) {
+                return localize(5568, "Start using AI Features");
+            }
+            else {
+                return localize(5569, "Enable more AI features");
+            }
+        }
+        if (this.context.state.entitlement === ChatEntitlement.Unknown || options?.forceSignInDialog) {
+            return localize(5570, "Sign in to use AI Features");
+        }
+        return localize(5568, "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(
+                5571,
+                "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}).",
+                defaultChat.provider.default.name,
+                defaultChat.termsStatementUrl,
+                defaultChat.privacyStatementUrl
+            ));
+        }
+        else {
+            footer = ( localize(
+                5572,
+                "By continuing, you agree to {0}'s [Terms]({1}) and [Privacy Statement]({2}). {3} Copilot may show [public code]({4}) suggestions and use your data to improve the product. You can change these [settings]({5}) anytime.",
+                defaultChat.provider.default.name,
+                defaultChat.termsStatementUrl,
+                defaultChat.privacyStatementUrl,
+                defaultChat.provider.default.name,
+                defaultChat.publicCodeMatchesUrl,
+                defaultChat.manageSettingsUrl
+            ));
+        }
+        element.appendChild($('p', undefined, disposables.add(this.markdownRendererService.render(( new MarkdownString(footer, { isTrusted: true })))).element));
+        return element;
+    }
+};
+ChatSetup = ChatSetup_1 = ( __decorate([
+    ( __param(2, ITelemetryService)),
+    ( __param(3, ILayoutService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IChatEntitlementService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IChatWidgetService)),
+    ( __param(9, IWorkspaceTrustRequestService)),
+    ( __param(10, IMarkdownRendererService))
+], ChatSetup));
+
+export { ChatSetup };

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

@@ -51,12 +51,10 @@
 	}
 }
 
-.monaco-workbench.hc-black .chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.apple::before,
-.monaco-workbench.vs-dark .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.apple::before {
+	background-image: url('./apple-light.svg');
 }
 
-.monaco-workbench.hc-light .chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.apple::before,
-.monaco-workbench.vs .chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.apple::before {
-	background-image: url('./apple-light.svg');
+.chat-setup-dialog .dialog-buttons-row > .dialog-buttons > .monaco-button.continue-button.apple::before {
+	background-image: url('./apple-dark.svg');
 }

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

@@ -0,0 +1,4 @@
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export declare function isNewUser(chatEntitlementService: IChatEntitlementService): boolean;
+export declare function isCompletionsEnabled(configurationService: IConfigurationService, modeId?: string): boolean;

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

@@ -0,0 +1,21 @@
+
+import { ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+function isNewUser(chatEntitlementService) {
+    return !chatEntitlementService.sentiment.installed ||
+        chatEntitlementService.entitlement === ChatEntitlement.Available;
+}
+function isCompletionsEnabled(configurationService, modeId = '*') {
+    const result = configurationService.getValue(product.defaultChatAgent.completionsEnablementSetting);
+    if (!isObject(result)) {
+        return false;
+    }
+    if (typeof result[modeId] !== 'undefined') {
+        return Boolean(result[modeId]);
+    }
+    return Boolean(result['*']);
+}
+
+export { isCompletionsEnabled, isNewUser };

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

@@ -0,0 +1,55 @@
+import { IInlineCompletionsService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/inlineCompletionsService.service";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { ITextResourceConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+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 { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IMarkdownRendererService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { DomWidget } from "../../../../../platform/domWidget/browser/domWidget.js";
+import { ChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatStatusItemService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatStatus/chatStatusItemService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+export declare class ChatStatusDashboard extends DomWidget {
+    private readonly chatEntitlementService;
+    private readonly chatStatusItemService;
+    private readonly commandService;
+    private readonly configurationService;
+    private readonly editorService;
+    private readonly hoverService;
+    private readonly languageService;
+    private readonly openerService;
+    private readonly telemetryService;
+    private readonly textResourceConfigurationService;
+    private readonly inlineCompletionsService;
+    private readonly chatSessionsService;
+    private readonly markdownRendererService;
+    private readonly languageFeaturesService;
+    private readonly quickInputService;
+    private readonly instantiationService;
+    readonly element: HTMLElement;
+    private readonly dateFormatter;
+    private readonly dateTimeFormatter;
+    private readonly quotaPercentageFormatter;
+    private readonly quotaOverageFormatter;
+    constructor(chatEntitlementService: ChatEntitlementService, chatStatusItemService: IChatStatusItemService, commandService: ICommandService, configurationService: IConfigurationService, editorService: IEditorService, hoverService: IHoverService, languageService: ILanguageService, openerService: IOpenerService, telemetryService: ITelemetryService, textResourceConfigurationService: ITextResourceConfigurationService, inlineCompletionsService: IInlineCompletionsService, chatSessionsService: IChatSessionsService, markdownRendererService: IMarkdownRendererService, languageFeaturesService: ILanguageFeaturesService, quickInputService: IQuickInputService, instantiationService: IInstantiationService);
+    private render;
+    private canUseChat;
+    private renderHeader;
+    private renderContributedChatStatusItem;
+    private renderTextPlus;
+    private runCommandAndClose;
+    private createQuotaIndicator;
+    private createSettings;
+    private createSetting;
+    private createInlineSuggestionsSetting;
+    private getCompletionsSettingAccessor;
+    private createNextEditSuggestionsSetting;
+    private createCompletionsSnooze;
+    private showModelPicker;
+}