@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/services/chat/common/chatEntitlementService.js

@@ -20,48 +20,47 @@ import { StorageScope, StorageTarget } from '../../../../platform/storage/common
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
 import { TelemetryLevel } from '../../../../platform/telemetry/common/telemetry.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
-import { IAuthenticationService, IAuthenticationExtensionsService } from '../../authentication/common/authentication.service.js';
+import { IAuthenticationService } from '../../authentication/common/authentication.service.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { URI } from '../../../../base/common/uri.js';
 import Severity$1 from '../../../../base/common/severity.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
 import { isWeb } from '../../../../base/common/platform.js';
-import { LifecyclePhase } from '../../lifecycle/common/lifecycle.js';
 import { ILifecycleService } from '../../lifecycle/common/lifecycle.service.js';
-import { distinct } from '../../../../base/common/arrays.js';
 import '../../../../platform/instantiation/common/extensions.js';
 import '../../../../base/common/observableInternal/index.js';
+import { IDefaultAccountService } from '../../../../platform/defaultAccount/common/defaultAccount.service.js';
 import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
 
-var ChatEntitlementRequests_1, ChatEntitlementContext_1;
+var ChatEntitlementContext_1;
 var ChatEntitlementContextKeys;
-(function (ChatEntitlementContextKeys) {
+(function(ChatEntitlementContextKeys) {
     ChatEntitlementContextKeys.Setup = {
-        hidden: ( new RawContextKey('chatSetupHidden', false, true)),
-        installed: ( new RawContextKey('chatSetupInstalled', false, true)),
-        disabled: ( new RawContextKey('chatSetupDisabled', false, true)),
-        untrusted: ( new RawContextKey('chatSetupUntrusted', false, true)),
-        later: ( new RawContextKey('chatSetupLater', false, true)),
-        registered: ( new RawContextKey('chatSetupRegistered', false, true))
+        hidden: ( new RawContextKey("chatSetupHidden", false, true)),
+        installed: ( new RawContextKey("chatSetupInstalled", false, true)),
+        disabled: ( new RawContextKey("chatSetupDisabled", false, true)),
+        untrusted: ( new RawContextKey("chatSetupUntrusted", false, true)),
+        later: ( new RawContextKey("chatSetupLater", false, true)),
+        registered: ( new RawContextKey("chatSetupRegistered", false, true))
     };
     ChatEntitlementContextKeys.Entitlement = {
-        signedOut: ( new RawContextKey('chatEntitlementSignedOut', false, true)),
-        canSignUp: ( new RawContextKey('chatPlanCanSignUp', false, true)),
-        planFree: ( new RawContextKey('chatPlanFree', false, true)),
-        planPro: ( new RawContextKey('chatPlanPro', false, true)),
-        planProPlus: ( new RawContextKey('chatPlanProPlus', false, true)),
-        planBusiness: ( new RawContextKey('chatPlanBusiness', false, true)),
-        planEnterprise: ( new RawContextKey('chatPlanEnterprise', false, true)),
-        organisations: ( new RawContextKey('chatEntitlementOrganisations', undefined, true)),
-        internal: ( new RawContextKey('chatEntitlementInternal', false, true)),
-        sku: ( new RawContextKey('chatEntitlementSku', undefined, true)),
+        signedOut: ( new RawContextKey("chatEntitlementSignedOut", false, true)),
+        canSignUp: ( new RawContextKey("chatPlanCanSignUp", false, true)),
+        planFree: ( new RawContextKey("chatPlanFree", false, true)),
+        planPro: ( new RawContextKey("chatPlanPro", false, true)),
+        planProPlus: ( new RawContextKey("chatPlanProPlus", false, true)),
+        planBusiness: ( new RawContextKey("chatPlanBusiness", false, true)),
+        planEnterprise: ( new RawContextKey("chatPlanEnterprise", false, true)),
+        organisations: ( new RawContextKey("chatEntitlementOrganisations", undefined, true)),
+        internal: ( new RawContextKey("chatEntitlementInternal", false, true)),
+        sku: ( new RawContextKey("chatEntitlementSku", undefined, true))
     };
-    ChatEntitlementContextKeys.chatQuotaExceeded = ( new RawContextKey('chatQuotaExceeded', false, true));
-    ChatEntitlementContextKeys.completionsQuotaExceeded = ( new RawContextKey('completionsQuotaExceeded', false, true));
-    ChatEntitlementContextKeys.chatAnonymous = ( new RawContextKey('chatAnonymous', false, true));
+    ChatEntitlementContextKeys.chatQuotaExceeded = ( new RawContextKey("chatQuotaExceeded", false, true));
+    ChatEntitlementContextKeys.completionsQuotaExceeded = ( new RawContextKey("completionsQuotaExceeded", false, true));
+    ChatEntitlementContextKeys.chatAnonymous = ( new RawContextKey("chatAnonymous", false, true));
 })(ChatEntitlementContextKeys || (ChatEntitlementContextKeys = {}));
 var ChatEntitlement;
-(function (ChatEntitlement) {
+(function(ChatEntitlement) {
     ChatEntitlement[ChatEntitlement["Unknown"] = 1] = "Unknown";
     ChatEntitlement[ChatEntitlement["Unresolved"] = 2] = "Unresolved";
     ChatEntitlement[ChatEntitlement["Available"] = 3] = "Available";
@@ -73,25 +72,29 @@ var ChatEntitlement;
     ChatEntitlement[ChatEntitlement["Enterprise"] = 9] = "Enterprise";
 })(ChatEntitlement || (ChatEntitlement = {}));
 function isProUser(chatEntitlement) {
-    return chatEntitlement === ChatEntitlement.Pro ||
-        chatEntitlement === ChatEntitlement.ProPlus ||
-        chatEntitlement === ChatEntitlement.Business ||
-        chatEntitlement === ChatEntitlement.Enterprise;
+    return chatEntitlement === ChatEntitlement.Pro || chatEntitlement === ChatEntitlement.ProPlus || chatEntitlement === ChatEntitlement.Business || chatEntitlement === ChatEntitlement.Enterprise;
 }
-const defaultChat = {
-    extensionId: product.defaultChatAgent?.extensionId ?? '',
-    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
-    upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? '',
-    provider: product.defaultChatAgent?.provider ?? { default: { id: '' }, enterprise: { id: '' } },
-    providerUriSetting: product.defaultChatAgent?.providerUriSetting ?? '',
-    providerScopes: product.defaultChatAgent?.providerScopes ?? [[]],
-    entitlementUrl: product.defaultChatAgent?.entitlementUrl ?? '',
-    entitlementSignupLimitedUrl: product.defaultChatAgent?.entitlementSignupLimitedUrl ?? '',
-    completionsAdvancedSetting: product.defaultChatAgent?.completionsAdvancedSetting ?? '',
-    chatQuotaExceededContext: product.defaultChatAgent?.chatQuotaExceededContext ?? '',
-    completionsQuotaExceededContext: product.defaultChatAgent?.completionsQuotaExceededContext ?? ''
+function getChatPlanName(chatEntitlement) {
+    switch (chatEntitlement) {
+    case ChatEntitlement.Pro:
+        return localize(14129, "Copilot Pro");
+    case ChatEntitlement.ProPlus:
+        return localize(14130, "Copilot Pro+");
+    case ChatEntitlement.Business:
+        return localize(14131, "Copilot Business");
+    case ChatEntitlement.Enterprise:
+        return localize(14132, "Copilot Enterprise");
+    default:
+        return localize(14133, "Copilot Free");
+    }
+}
+const defaultChatAgent = {
+    upgradePlanUrl: product.defaultChatAgent?.upgradePlanUrl ?? "",
+    entitlementSignupLimitedUrl: product.defaultChatAgent?.entitlementSignupLimitedUrl ?? "",
+    chatQuotaExceededContext: product.defaultChatAgent?.chatQuotaExceededContext ?? "",
+    completionsQuotaExceededContext: product.defaultChatAgent?.completionsQuotaExceededContext ?? ""
 };
-const CHAT_ALLOW_ANONYMOUS_CONFIGURATION_KEY = 'chat.allowAnonymousAccess';
+const CHAT_ALLOW_ANONYMOUS_CONFIGURATION_KEY = "chat.allowAnonymousAccess";
 function isAnonymous(configurationService, entitlement, sentiment) {
     if (configurationService.getValue(CHAT_ALLOW_ANONYMOUS_CONFIGURATION_KEY) !== true) {
         return false;
@@ -105,7 +108,7 @@ function isAnonymous(configurationService, entitlement, sentiment) {
     return true;
 }
 function logChatEntitlements(state, configurationService, telemetryService) {
-    telemetryService.publicLog2('chatEntitlements', {
+    telemetryService.publicLog2("chatEntitlements", {
         chatHidden: Boolean(state.hidden),
         chatDisabled: Boolean(state.disabled),
         chatEntitlement: state.entitlement,
@@ -114,20 +117,26 @@ function logChatEntitlements(state, configurationService, telemetryService) {
     });
 }
 let ChatEntitlementService = class ChatEntitlementService extends Disposable {
-    constructor(instantiationService, productService, environmentService, contextKeyService, configurationService, telemetryService, lifecycleService) {
+    constructor(
+        instantiationService,
+        productService,
+        environmentService,
+        contextKeyService,
+        configurationService,
+        telemetryService
+    ) {
         super();
         this.contextKeyService = contextKeyService;
         this.configurationService = configurationService;
         this.telemetryService = telemetryService;
-        this.lifecycleService = lifecycleService;
         this._onDidChangeQuotaExceeded = this._register(( new Emitter()));
         this.onDidChangeQuotaExceeded = this._onDidChangeQuotaExceeded.event;
         this._onDidChangeQuotaRemaining = this._register(( new Emitter()));
         this.onDidChangeQuotaRemaining = this._onDidChangeQuotaRemaining.event;
         this._quotas = {};
         this.ExtensionQuotaContextKeys = {
-            chatQuotaExceeded: defaultChat.chatQuotaExceededContext,
-            completionsQuotaExceeded: defaultChat.completionsQuotaExceededContext,
+            chatQuotaExceeded: defaultChatAgent.chatQuotaExceededContext,
+            completionsQuotaExceeded: defaultChatAgent.completionsQuotaExceededContext
         };
         this._onDidChangeAnonymous = this._register(( new Emitter()));
         this.onDidChangeAnonymous = this._onDidChangeAnonymous.event;
@@ -136,8 +145,9 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
         this.completionsQuotaExceededContextKey = ChatEntitlementContextKeys.completionsQuotaExceeded.bindTo(this.contextKeyService);
         this.anonymousContextKey = ChatEntitlementContextKeys.chatAnonymous.bindTo(this.contextKeyService);
         this.anonymousContextKey.set(this.anonymous);
-        this.onDidChangeEntitlement = ( Event.map(
-            Event.filter(this.contextKeyService.onDidChangeContext, e => e.affectsSome(( new Set([
+        this.onDidChangeEntitlement = ( Event.map(Event.filter(
+            this.contextKeyService.onDidChangeContext,
+            e => e.affectsSome(( new Set([
                 ChatEntitlementContextKeys.Entitlement.planPro.key,
                 ChatEntitlementContextKeys.Entitlement.planBusiness.key,
                 ChatEntitlementContextKeys.Entitlement.planEnterprise.key,
@@ -148,23 +158,22 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
                 ChatEntitlementContextKeys.Entitlement.organisations.key,
                 ChatEntitlementContextKeys.Entitlement.internal.key,
                 ChatEntitlementContextKeys.Entitlement.sku.key
-            ]))), this._store),
-            () => { },
+            ]))),
             this._store
-        ));
+        ), () => {}, this._store));
         this.entitlementObs = observableFromEvent(this.onDidChangeEntitlement, () => this.entitlement);
-        this.onDidChangeSentiment = ( Event.map(
-            Event.filter(this.contextKeyService.onDidChangeContext, e => e.affectsSome(( new Set([
+        this.onDidChangeSentiment = ( Event.map(Event.filter(
+            this.contextKeyService.onDidChangeContext,
+            e => e.affectsSome(( new Set([
                 ChatEntitlementContextKeys.Setup.hidden.key,
                 ChatEntitlementContextKeys.Setup.disabled.key,
                 ChatEntitlementContextKeys.Setup.untrusted.key,
                 ChatEntitlementContextKeys.Setup.installed.key,
                 ChatEntitlementContextKeys.Setup.later.key,
                 ChatEntitlementContextKeys.Setup.registered.key
-            ]))), this._store),
-            () => { },
+            ]))),
             this._store
-        ));
+        ), () => {}, this._store));
         this.sentimentObs = observableFromEvent(this.onDidChangeSentiment, () => this.sentiment);
         if ((isWeb && !environmentService.remoteAuthority)) {
             ChatEntitlementContextKeys.Setup.hidden.bindTo(this.contextKeyService).set(true);
@@ -176,34 +185,28 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
         const context = this.context = ( new Lazy(
             () => this._register(instantiationService.createInstance(ChatEntitlementContext))
         ));
-        this.requests = ( new Lazy(
-            () => this._register(instantiationService.createInstance(ChatEntitlementRequests, context.value, {
+        this.requests = ( new Lazy(() => this._register(
+            instantiationService.createInstance(ChatEntitlementRequests, context.value, {
                 clearQuotas: () => this.clearQuotas(),
                 acceptQuotas: quotas => this.acceptQuotas(quotas)
-            }))
-        ));
+            })
+        )));
         this.registerListeners();
     }
     get entitlement() {
         if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planPro.key) === true) {
             return ChatEntitlement.Pro;
-        }
-        else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planBusiness.key) === true) {
+        } else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planBusiness.key) === true) {
             return ChatEntitlement.Business;
-        }
-        else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planEnterprise.key) === true) {
+        } else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planEnterprise.key) === true) {
             return ChatEntitlement.Enterprise;
-        }
-        else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planProPlus.key) === true) {
+        } else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planProPlus.key) === true) {
             return ChatEntitlement.ProPlus;
-        }
-        else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planFree.key) === true) {
+        } else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.planFree.key) === true) {
             return ChatEntitlement.Free;
-        }
-        else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.canSignUp.key) === true) {
+        } else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.canSignUp.key) === true) {
             return ChatEntitlement.Available;
-        }
-        else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.signedOut.key) === true) {
+        } else if (this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.signedOut.key) === true) {
             return ChatEntitlement.Unknown;
         }
         return ChatEntitlement.Unresolved;
@@ -217,11 +220,14 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
     get sku() {
         return this.contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.Entitlement.sku.key);
     }
-    get quotas() { return this._quotas; }
+    get quotas() {
+        return this._quotas;
+    }
     registerListeners() {
-        const quotaExceededSet = ( new Set(
-            [this.ExtensionQuotaContextKeys.chatQuotaExceeded, this.ExtensionQuotaContextKeys.completionsQuotaExceeded]
-        ));
+        const quotaExceededSet = ( new Set([
+            this.ExtensionQuotaContextKeys.chatQuotaExceeded,
+            this.ExtensionQuotaContextKeys.completionsQuotaExceeded
+        ]));
         const cts = this._register(( new MutableDisposable()));
         this._register(this.contextKeyService.onDidChangeContext(e => {
             if (e.affectsSome(quotaExceededSet)) {
@@ -251,19 +257,20 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
         }));
         this._register(this.onDidChangeEntitlement(() => updateAnonymousUsage()));
         this._register(this.onDidChangeSentiment(() => updateAnonymousUsage()));
-        this.lifecycleService.when(LifecyclePhase.Eventually).then(() => {
-            if (this.context?.hasValue) {
-                logChatEntitlements(this.context.value.state, this.configurationService, this.telemetryService);
-            }
-        });
     }
     acceptQuotas(quotas) {
         const oldQuota = this._quotas;
         this._quotas = quotas;
         this.updateContextKeys();
-        const { changed: chatChanged } = this.compareQuotas(oldQuota.chat, quotas.chat);
-        const { changed: completionsChanged } = this.compareQuotas(oldQuota.completions, quotas.completions);
-        const { changed: premiumChatChanged } = this.compareQuotas(oldQuota.premiumChat, quotas.premiumChat);
+        const {
+            changed: chatChanged
+        } = this.compareQuotas(oldQuota.chat, quotas.chat);
+        const {
+            changed: completionsChanged
+        } = this.compareQuotas(oldQuota.completions, quotas.completions);
+        const {
+            changed: premiumChatChanged
+        } = this.compareQuotas(oldQuota.premiumChat, quotas.premiumChat);
         if (chatChanged.exceeded || completionsChanged.exceeded || premiumChatChanged.exceeded) {
             this._onDidChangeQuotaExceeded.fire();
         }
@@ -300,64 +307,49 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
         return isAnonymous(this.configurationService, this.entitlement, this.sentiment);
     }
     async update(token) {
-        await this.requests?.value.forceResolveEntitlement(undefined, token);
+        await this.requests?.value.forceResolveEntitlement(token);
     }
 };
-ChatEntitlementService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IProductService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, ILifecycleService))
-], ChatEntitlementService));
-let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementRequests extends Disposable {
-    static providerId(configurationService) {
-        if (configurationService.getValue(`${defaultChat.completionsAdvancedSetting}.authProvider`) === defaultChat.provider.enterprise.id) {
-            return defaultChat.provider.enterprise.id;
-        }
-        return defaultChat.provider.default.id;
-    }
-    constructor(context, chatQuotasAccessor, telemetryService, authenticationService, logService, requestService, dialogService, openerService, configurationService, authenticationExtensionsService, lifecycleService) {
+ChatEntitlementService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IProductService)), ( __param(2, IWorkbenchEnvironmentService)), ( __param(3, IContextKeyService)), ( __param(4, IConfigurationService)), ( __param(5, ITelemetryService))], ChatEntitlementService));
+let ChatEntitlementRequests = class ChatEntitlementRequests extends Disposable {
+    constructor(
+        context,
+        chatQuotasAccessor,
+        telemetryService,
+        logService,
+        requestService,
+        dialogService,
+        openerService,
+        lifecycleService,
+        defaultAccountService,
+        authenticationService
+    ) {
         super();
         this.context = context;
         this.chatQuotasAccessor = chatQuotasAccessor;
         this.telemetryService = telemetryService;
-        this.authenticationService = authenticationService;
         this.logService = logService;
         this.requestService = requestService;
         this.dialogService = dialogService;
         this.openerService = openerService;
-        this.configurationService = configurationService;
-        this.authenticationExtensionsService = authenticationExtensionsService;
         this.lifecycleService = lifecycleService;
+        this.defaultAccountService = defaultAccountService;
+        this.authenticationService = authenticationService;
         this.pendingResolveCts = ( new CancellationTokenSource());
-        this.didResolveEntitlements = false;
-        this.state = { entitlement: this.context.state.entitlement };
+        this.state = {
+            entitlement: this.context.state.entitlement
+        };
         this.registerListeners();
         this.resolve();
     }
     registerListeners() {
-        this._register(this.authenticationService.onDidChangeDeclaredProviders(() => this.resolve()));
-        this._register(this.authenticationService.onDidChangeSessions(e => {
-            if (e.providerId === ChatEntitlementRequests_1.providerId(this.configurationService)) {
-                this.resolve();
-            }
-        }));
-        this._register(this.authenticationService.onDidRegisterAuthenticationProvider(e => {
-            if (e.id === ChatEntitlementRequests_1.providerId(this.configurationService)) {
-                this.resolve();
-            }
-        }));
-        this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(e => {
-            if (e.id === ChatEntitlementRequests_1.providerId(this.configurationService)) {
-                this.resolve();
-            }
-        }));
+        this._register(this.defaultAccountService.onDidChangeDefaultAccount(() => this.resolve()));
         this._register(this.context.onDidChange(() => {
             if (!this.context.state.installed || this.context.state.disabled || this.context.state.entitlement === ChatEntitlement.Unknown) {
-                this.state = { entitlement: this.state.entitlement, quotas: undefined };
+                this.state = {
+                    entitlement: this.state.entitlement,
+                    quotas: undefined
+                };
                 this.chatQuotasAccessor.clearQuotas();
             }
         }));
@@ -365,144 +357,75 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
     async resolve() {
         this.pendingResolveCts.dispose(true);
         const cts = this.pendingResolveCts = ( new CancellationTokenSource());
-        const session = await this.findMatchingProviderSession(cts.token);
+        const defaultAccount = await this.defaultAccountService.getDefaultAccount();
         if (cts.token.isCancellationRequested) {
             return;
         }
         let state = undefined;
-        if (session) {
+        if (defaultAccount) {
             if (this.state.entitlement === ChatEntitlement.Unknown) {
-                state = { entitlement: ChatEntitlement.Unresolved };
+                state = {
+                    entitlement: ChatEntitlement.Unresolved
+                };
             }
-        }
-        else {
-            this.didResolveEntitlements = false;
-            state = { entitlement: ChatEntitlement.Unknown };
+        } else {
+            state = {
+                entitlement: ChatEntitlement.Unknown
+            };
         }
         if (state) {
             this.update(state);
         }
-        if (session && !this.didResolveEntitlements) {
-            await this.resolveEntitlement(session, cts.token);
-        }
-    }
-    async findMatchingProviderSession(token) {
-        const sessions = await this.doGetSessions(ChatEntitlementRequests_1.providerId(this.configurationService));
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        const matchingSessions = ( new Set());
-        for (const session of sessions) {
-            for (const scopes of defaultChat.providerScopes) {
-                if (this.includesScopes(session.scopes, scopes)) {
-                    matchingSessions.add(session);
-                }
-            }
+        if (defaultAccount) {
+            await this.resolveEntitlement(defaultAccount, cts.token);
         }
-        return matchingSessions.size > 0 ? Array.from(matchingSessions) : undefined;
     }
-    async doGetSessions(providerId) {
-        const preferredAccountName = this.authenticationExtensionsService.getAccountPreference(defaultChat.chatExtensionId, providerId) ?? this.authenticationExtensionsService.getAccountPreference(defaultChat.extensionId, providerId);
-        let preferredAccount;
-        for (const account of await this.authenticationService.getAccounts(providerId)) {
-            if (account.label === preferredAccountName) {
-                preferredAccount = account;
-                break;
-            }
-        }
-        try {
-            return await this.authenticationService.getSessions(providerId, undefined, { account: preferredAccount });
-        }
-        catch (error) {
-        }
-        return [];
-    }
-    includesScopes(scopes, expectedScopes) {
-        return expectedScopes.every(scope => scopes.includes(scope));
-    }
-    async resolveEntitlement(sessions, token) {
-        const entitlements = await this.doResolveEntitlement(sessions, token);
-        if (typeof entitlements?.entitlement === 'number' && !token.isCancellationRequested) {
-            this.didResolveEntitlements = true;
+    async resolveEntitlement(defaultAccount, token) {
+        const entitlements = await this.doResolveEntitlement(defaultAccount, token);
+        if (typeof entitlements?.entitlement === "number" && !token.isCancellationRequested) {
             this.update(entitlements);
         }
         return entitlements;
     }
-    async doResolveEntitlement(sessions, token) {
+    async doResolveEntitlement(defaultAccount, token) {
         if (token.isCancellationRequested) {
             return undefined;
         }
-        const response = await this.request(this.getEntitlementUrl(), 'GET', undefined, sessions, token);
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        if (!response) {
-            this.logService.trace('[chat entitlement]: no response');
-            return { entitlement: ChatEntitlement.Unresolved };
-        }
-        if (response.res.statusCode && response.res.statusCode !== 200) {
-            this.logService.trace(`[chat entitlement]: unexpected status code ${response.res.statusCode}`);
-            return ((
-            response.res.statusCode === 401 || response.res.statusCode === 404)
-            ) ? { entitlement: ChatEntitlement.Unknown  } : { entitlement: ChatEntitlement.Unresolved };
-        }
-        let responseText = null;
-        try {
-            responseText = await asText(response);
-        }
-        catch (error) {
-        }
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        if (!responseText) {
-            this.logService.trace('[chat entitlement]: response has no content');
-            return { entitlement: ChatEntitlement.Unresolved };
-        }
-        let entitlementsResponse;
-        try {
-            entitlementsResponse = JSON.parse(responseText);
-            this.logService.trace(`[chat entitlement]: parsed result is ${JSON.stringify(entitlementsResponse)}`);
-        }
-        catch (err) {
-            this.logService.trace(`[chat entitlement]: error parsing response (${err})`);
-            return { entitlement: ChatEntitlement.Unresolved };
+        const entitlementsData = defaultAccount.entitlementsData;
+        if (!entitlementsData) {
+            this.logService.trace("[chat entitlement]: no entitlements data available on default account");
+            return {
+                entitlement: entitlementsData === null ? ChatEntitlement.Unknown : ChatEntitlement.Unresolved
+            };
         }
         let entitlement;
-        if (entitlementsResponse.access_type_sku === 'free_limited_copilot') {
+        if (entitlementsData.access_type_sku === "free_limited_copilot") {
             entitlement = ChatEntitlement.Free;
-        }
-        else if (entitlementsResponse.can_signup_for_limited) {
+        } else if (entitlementsData.can_signup_for_limited) {
             entitlement = ChatEntitlement.Available;
-        }
-        else if (entitlementsResponse.copilot_plan === 'individual') {
+        } else if (entitlementsData.copilot_plan === "individual") {
             entitlement = ChatEntitlement.Pro;
-        }
-        else if (entitlementsResponse.copilot_plan === 'individual_pro') {
+        } else if (entitlementsData.copilot_plan === "individual_pro") {
             entitlement = ChatEntitlement.ProPlus;
-        }
-        else if (entitlementsResponse.copilot_plan === 'business') {
+        } else if (entitlementsData.copilot_plan === "business") {
             entitlement = ChatEntitlement.Business;
-        }
-        else if (entitlementsResponse.copilot_plan === 'enterprise') {
+        } else if (entitlementsData.copilot_plan === "enterprise") {
             entitlement = ChatEntitlement.Enterprise;
-        }
-        else if (entitlementsResponse.chat_enabled) {
-            entitlement = ChatEntitlement.Pro;
-        }
-        else {
+        } else {
             entitlement = ChatEntitlement.Unavailable;
         }
         const entitlements = {
             entitlement,
-            organisations: entitlementsResponse.organization_login_list,
-            quotas: this.toQuotas(entitlementsResponse),
-            sku: entitlementsResponse.access_type_sku
+            organisations: entitlementsData.organization_login_list,
+            quotas: this.toQuotas(entitlementsData),
+            sku: entitlementsData.access_type_sku
         };
-        this.logService.trace(`[chat entitlement]: resolved to ${entitlements.entitlement}, quotas: ${JSON.stringify(entitlements.quotas)}`);
-        this.telemetryService.publicLog2('chatInstallEntitlement', {
+        this.logService.trace(
+            `[chat entitlement]: resolved to ${entitlements.entitlement}, quotas: ${JSON.stringify(entitlements.quotas)}`
+        );
+        this.telemetryService.publicLog2("chatInstallEntitlement", {
             entitlement: entitlements.entitlement,
-            tid: entitlementsResponse.analytics_tracking_id,
+            tid: entitlementsData.analytics_tracking_id,
             sku: entitlements.sku,
             quotaChat: entitlements.quotas?.chat?.remaining,
             quotaPremiumChat: entitlements.quotas?.premiumChat?.remaining,
@@ -511,46 +434,40 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
         });
         return entitlements;
     }
-    getEntitlementUrl() {
-        if (ChatEntitlementRequests_1.providerId(this.configurationService) === defaultChat.provider.enterprise.id) {
-            try {
-                const enterpriseUrl = ( new URL(this.configurationService.getValue(defaultChat.providerUriSetting)));
-                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ':' + enterpriseUrl.port : ''}/copilot_internal/user`;
-            }
-            catch (error) {
-                this.logService.error(error);
-            }
-        }
-        return defaultChat.entitlementUrl;
-    }
-    toQuotas(response) {
+    toQuotas(entitlementsData) {
         const quotas = {
-            resetDate: response.quota_reset_date_utc ?? response.quota_reset_date ?? response.limited_user_reset_date,
-            resetDateHasTime: typeof response.quota_reset_date_utc === 'string',
+            resetDate: entitlementsData.quota_reset_date_utc ?? entitlementsData.quota_reset_date ?? entitlementsData.limited_user_reset_date,
+            resetDateHasTime: typeof entitlementsData.quota_reset_date_utc === "string"
         };
-        if (response.monthly_quotas?.chat && typeof response.limited_user_quotas?.chat === 'number') {
+        if (entitlementsData.monthly_quotas?.chat && typeof entitlementsData.limited_user_quotas?.chat === "number") {
             quotas.chat = {
-                total: response.monthly_quotas.chat,
-                remaining: response.limited_user_quotas.chat,
-                percentRemaining: Math.min(100, Math.max(0, (response.limited_user_quotas.chat / response.monthly_quotas.chat) * 100)),
+                total: entitlementsData.monthly_quotas.chat,
+                remaining: entitlementsData.limited_user_quotas.chat,
+                percentRemaining: Math.min(100, Math.max(
+                    0,
+                    (entitlementsData.limited_user_quotas.chat / entitlementsData.monthly_quotas.chat) * 100
+                )),
                 overageEnabled: false,
                 overageCount: 0,
                 unlimited: false
             };
         }
-        if (response.monthly_quotas?.completions && typeof response.limited_user_quotas?.completions === 'number') {
+        if (entitlementsData.monthly_quotas?.completions && typeof entitlementsData.limited_user_quotas?.completions === "number") {
             quotas.completions = {
-                total: response.monthly_quotas.completions,
-                remaining: response.limited_user_quotas.completions,
-                percentRemaining: Math.min(100, Math.max(0, (response.limited_user_quotas.completions / response.monthly_quotas.completions) * 100)),
+                total: entitlementsData.monthly_quotas.completions,
+                remaining: entitlementsData.limited_user_quotas.completions,
+                percentRemaining: Math.min(100, Math.max(
+                    0,
+                    (entitlementsData.limited_user_quotas.completions / entitlementsData.monthly_quotas.completions) * 100
+                )),
                 overageEnabled: false,
                 overageCount: 0,
                 unlimited: false
             };
         }
-        if (response.quota_snapshots) {
-            for (const quotaType of ['chat', 'completions', 'premium_interactions']) {
-                const rawQuotaSnapshot = response.quota_snapshots[quotaType];
+        if (entitlementsData.quota_snapshots) {
+            for (const quotaType of ["chat", "completions", "premium_interactions"]) {
+                const rawQuotaSnapshot = entitlementsData.quota_snapshots[quotaType];
                 if (!rawQuotaSnapshot) {
                     continue;
                 }
@@ -563,15 +480,15 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
                     unlimited: rawQuotaSnapshot.unlimited
                 };
                 switch (quotaType) {
-                    case 'chat':
-                        quotas.chat = quotaSnapshot;
-                        break;
-                    case 'completions':
-                        quotas.completions = quotaSnapshot;
-                        break;
-                    case 'premium_interactions':
-                        quotas.premiumChat = quotaSnapshot;
-                        break;
+                case "chat":
+                    quotas.chat = quotaSnapshot;
+                    break;
+                case "completions":
+                    quotas.completions = quotaSnapshot;
+                    break;
+                case "premium_interactions":
+                    quotas.premiumChat = quotaSnapshot;
+                    break;
                 }
             }
         }
@@ -587,10 +504,10 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
                 const response = await this.requestService.request({
                     type,
                     url,
-                    data: type === 'POST' ? JSON.stringify(body) : undefined,
+                    data: type === "POST" ? JSON.stringify(body) : undefined,
                     disableCache: true,
                     headers: {
-                        'Authorization': `Bearer ${session.accessToken}`
+                        "Authorization": `Bearer ${session.accessToken}`
                     }
                 }, token);
                 const status = response.res.statusCode;
@@ -599,8 +516,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
                     continue;
                 }
                 return response;
-            }
-            catch (error) {
+            } catch (error) {
                 if (!token.isCancellationRequested) {
                     this.logService.error(`[chat entitlement] request: error ${error}`);
                 }
@@ -610,29 +526,46 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
     }
     update(state) {
         this.state = state;
-        this.context.update({ entitlement: this.state.entitlement, organisations: this.state.organisations, sku: this.state.sku });
+        this.context.update({
+            entitlement: this.state.entitlement,
+            organisations: this.state.organisations,
+            sku: this.state.sku
+        });
         if (state.quotas) {
             this.chatQuotasAccessor.acceptQuotas(state.quotas);
         }
     }
-    async forceResolveEntitlement(sessions, token = CancellationToken.None) {
-        if (!sessions) {
-            sessions = await this.findMatchingProviderSession(token);
+    async forceResolveEntitlement(token = CancellationToken.None) {
+        const defaultAccount = await this.defaultAccountService.refresh();
+        if (!defaultAccount) {
+            return undefined;
         }
-        if (!sessions || sessions.length === 0) {
+        return this.resolveEntitlement(defaultAccount, token);
+    }
+    async signUpFree() {
+        const sessions = await this.getSessions();
+        if (sessions.length === 0) {
             return undefined;
         }
-        return this.resolveEntitlement(sessions, token);
+        return this.doSignUpFree(sessions);
     }
-    async signUpFree(sessions) {
+    async doSignUpFree(sessions) {
         const body = {
-            restricted_telemetry: this.telemetryService.telemetryLevel === TelemetryLevel.NONE ? 'disabled' : 'enabled',
-            public_code_suggestions: 'enabled'
+            restricted_telemetry: this.telemetryService.telemetryLevel === TelemetryLevel.NONE ? "disabled" : "enabled",
+            public_code_suggestions: "enabled"
         };
-        const response = await this.request(defaultChat.entitlementSignupLimitedUrl, 'POST', body, sessions, CancellationToken.None);
+        const response = await this.request(
+            defaultChatAgent.entitlementSignupLimitedUrl,
+            "POST",
+            body,
+            sessions,
+            CancellationToken.None
+        );
         if (!response) {
-            const retry = await this.onUnknownSignUpError(( localize(13747, "No response received.")), '[chat entitlement] sign-up: no response');
-            return retry ? this.signUpFree(sessions) : { errorCode: 1 };
+            const retry = await this.onUnknownSignUpError(( localize(14134, "No response received.")), "[chat entitlement] sign-up: no response");
+            return retry ? this.doSignUpFree(sessions) : {
+                errorCode: 1
+            };
         }
         if (response.res.statusCode && response.res.statusCode !== 200) {
             if (response.res.statusCode === 422) {
@@ -640,51 +573,74 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
                     const responseText = await asText(response);
                     if (responseText) {
                         const responseError = JSON.parse(responseText);
-                        if (typeof responseError.message === 'string' && responseError.message) {
-                            this.onUnprocessableSignUpError(`[chat entitlement] sign-up: unprocessable entity (${responseError.message})`, responseError.message);
-                            return { errorCode: response.res.statusCode };
+                        if (typeof responseError.message === "string" && responseError.message) {
+                            this.onUnprocessableSignUpError(
+                                `[chat entitlement] sign-up: unprocessable entity (${responseError.message})`,
+                                responseError.message
+                            );
+                            return {
+                                errorCode: response.res.statusCode
+                            };
                         }
                     }
-                }
-                catch (error) {
-                }
+                } catch (error) {}
             }
-            const retry = await this.onUnknownSignUpError(( localize(13748, "Unexpected status code {0}.", response.res.statusCode)), `[chat entitlement] sign-up: unexpected status code ${response.res.statusCode}`);
-            return retry ? this.signUpFree(sessions) : { errorCode: response.res.statusCode };
+            const retry = await this.onUnknownSignUpError(( localize(14135, "Unexpected status code {0}.", response.res.statusCode)), `[chat entitlement] sign-up: unexpected status code ${response.res.statusCode}`);
+            return retry ? this.doSignUpFree(sessions) : {
+                errorCode: response.res.statusCode
+            };
         }
         let responseText = null;
         try {
             responseText = await asText(response);
-        }
-        catch (error) {
-        }
+        } catch (error) {}
         if (!responseText) {
-            const retry = await this.onUnknownSignUpError(( localize(13749, "Response has no contents.")), '[chat entitlement] sign-up: response has no content');
-            return retry ? this.signUpFree(sessions) : { errorCode: 2 };
+            const retry = await this.onUnknownSignUpError(( localize(14136, "Response has no contents.")), "[chat entitlement] sign-up: response has no content");
+            return retry ? this.doSignUpFree(sessions) : {
+                errorCode: 2
+            };
         }
         let parsedResult = undefined;
         try {
             parsedResult = JSON.parse(responseText);
             this.logService.trace(`[chat entitlement] sign-up: response is ${responseText}`);
+        } catch (err) {
+            const retry = await this.onUnknownSignUpError(( localize(14137, "Invalid response contents.")), `[chat entitlement] sign-up: error parsing response (${err})`);
+            return retry ? this.doSignUpFree(sessions) : {
+                errorCode: 3
+            };
         }
-        catch (err) {
-            const retry = await this.onUnknownSignUpError(( localize(13750, "Invalid response contents.")), `[chat entitlement] sign-up: error parsing response (${err})`);
-            return retry ? this.signUpFree(sessions) : { errorCode: 3 };
-        }
-        this.update({ entitlement: ChatEntitlement.Free });
+        this.update({
+            entitlement: ChatEntitlement.Free
+        });
         return Boolean(parsedResult?.subscribed);
     }
+    async getSessions() {
+        const defaultAccount = await this.defaultAccountService.getDefaultAccount();
+        if (defaultAccount) {
+            const sessions = await this.authenticationService.getSessions(defaultAccount.authenticationProvider.id);
+            const accountSessions = sessions.filter(s => s.id === defaultAccount.sessionId);
+            if (accountSessions.length) {
+                return accountSessions;
+            }
+        }
+        return [
+            ...(await this.authenticationService.getSessions(this.defaultAccountService.getDefaultAccountAuthenticationProvider().id))
+        ];
+    }
     async onUnknownSignUpError(detail, logMessage) {
         this.logService.error(logMessage);
         if (!this.lifecycleService.willShutdown) {
-            const { confirmed } = await this.dialogService.confirm({
+            const {
+                confirmed
+            } = await this.dialogService.confirm({
                 type: Severity$1.Error,
                 message: ( localize(
-                    13751,
+                    14138,
                     "An error occurred while signing up for the GitHub Copilot Free plan. Would you like to try again?"
                 )),
                 detail,
-                primaryButton: ( localize(13752, "Retry"))
+                primaryButton: ( localize(14139, "Retry"))
             });
             return confirmed;
         }
@@ -696,57 +652,63 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
             this.dialogService.prompt({
                 type: Severity$1.Error,
                 message: ( localize(
-                    13753,
+                    14140,
                     "An error occurred while signing up for the GitHub Copilot Free plan."
                 )),
                 detail: logDetails,
-                buttons: [
-                    {
-                        label: ( localize(13754, "OK")),
-                        run: () => { }
-                    },
-                    {
-                        label: ( localize(13755, "Learn More")),
-                        run: () => this.openerService.open(( URI.parse(defaultChat.upgradePlanUrl)))
-                    }
-                ]
+                buttons: [{
+                    label: ( localize(14141, "OK")),
+                    run: () => {}
+                }, {
+                    label: ( localize(14142, "Learn More")),
+                    run: () => this.openerService.open(( URI.parse(defaultChatAgent.upgradePlanUrl)))
+                }]
             });
         }
     }
     async signIn(options) {
-        const providerId = ChatEntitlementRequests_1.providerId(this.configurationService);
-        const scopes = options?.additionalScopes ? distinct([...defaultChat.providerScopes[0], ...options.additionalScopes]) : defaultChat.providerScopes[0];
-        const session = await this.authenticationService.createSession(providerId, scopes, {
-            extraAuthorizeParameters: { get_started_with: 'copilot-vscode' },
+        const defaultAccount = await this.defaultAccountService.signIn({
+            additionalScopes: options?.additionalScopes,
+            extraAuthorizeParameters: {
+                get_started_with: "copilot-vscode"
+            },
             provider: options?.useSocialProvider
         });
-        this.authenticationExtensionsService.updateAccountPreference(defaultChat.extensionId, providerId, session.account);
-        this.authenticationExtensionsService.updateAccountPreference(defaultChat.chatExtensionId, providerId, session.account);
-        const entitlements = await this.forceResolveEntitlement([session]);
-        return { session, entitlements };
+        if (!defaultAccount) {
+            return {};
+        }
+        const entitlements = await this.doResolveEntitlement(defaultAccount, CancellationToken.None);
+        return {
+            defaultAccount,
+            entitlements
+        };
     }
     dispose() {
         this.pendingResolveCts.dispose(true);
         super.dispose();
     }
 };
-ChatEntitlementRequests = ChatEntitlementRequests_1 = ( __decorate([
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IAuthenticationService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IRequestService)),
-    ( __param(6, IDialogService)),
-    ( __param(7, IOpenerService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, IAuthenticationExtensionsService)),
-    ( __param(10, ILifecycleService))
-], ChatEntitlementRequests));
+ChatEntitlementRequests = ( __decorate([( __param(2, ITelemetryService)), ( __param(3, ILogService)), ( __param(4, IRequestService)), ( __param(5, IDialogService)), ( __param(6, IOpenerService)), ( __param(7, ILifecycleService)), ( __param(8, IDefaultAccountService)), ( __param(9, IAuthenticationService))], ChatEntitlementRequests));
 let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
-    static { ChatEntitlementContext_1 = this; }
-    static { this.CHAT_ENTITLEMENT_CONTEXT_STORAGE_KEY = 'chat.setupContext'; }
-    static { this.CHAT_DISABLED_CONFIGURATION_KEY = 'chat.disableAIFeatures'; }
-    get state() { return this.withConfiguration(this.suspendedState ?? this._state); }
-    constructor(contextKeyService, storageService, logService, configurationService, telemetryService) {
+    static {
+        ChatEntitlementContext_1 = this;
+    }
+    static {
+        this.CHAT_ENTITLEMENT_CONTEXT_STORAGE_KEY = "chat.setupContext";
+    }
+    static {
+        this.CHAT_DISABLED_CONFIGURATION_KEY = "chat.disableAIFeatures";
+    }
+    get state() {
+        return this.withConfiguration(this.suspendedState ?? this._state);
+    }
+    constructor(
+        contextKeyService,
+        storageService,
+        logService,
+        configurationService,
+        telemetryService
+    ) {
         super();
         this.storageService = storageService;
         this.logService = logService;
@@ -772,7 +734,14 @@ let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
         this.disabledContext = ChatEntitlementContextKeys.Setup.disabled.bindTo(contextKeyService);
         this.untrustedContext = ChatEntitlementContextKeys.Setup.untrusted.bindTo(contextKeyService);
         this.registeredContext = ChatEntitlementContextKeys.Setup.registered.bindTo(contextKeyService);
-        this._state = this.storageService.getObject(ChatEntitlementContext_1.CHAT_ENTITLEMENT_CONTEXT_STORAGE_KEY, StorageScope.PROFILE) ?? { entitlement: ChatEntitlement.Unknown, organisations: undefined, sku: undefined };
+        this._state = this.storageService.getObject(
+            ChatEntitlementContext_1.CHAT_ENTITLEMENT_CONTEXT_STORAGE_KEY,
+            StorageScope.PROFILE
+        ) ?? {
+            entitlement: ChatEntitlement.Unknown,
+            organisations: undefined,
+            sku: undefined
+        };
         this.updateContextSync();
         this.registerListeners();
     }
@@ -795,7 +764,7 @@ let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
     async update(context) {
         this.logService.trace(`[chat entitlement context] update(): ${JSON.stringify(context)}`);
         const oldState = JSON.stringify(this._state);
-        if (typeof context.installed === 'boolean' && typeof context.disabled === 'boolean' && typeof context.untrusted === 'boolean') {
+        if (typeof context.installed === "boolean" && typeof context.disabled === "boolean" && typeof context.untrusted === "boolean") {
             this._state.installed = context.installed;
             this._state.disabled = context.disabled;
             this._state.untrusted = context.untrusted;
@@ -803,25 +772,24 @@ let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
                 context.hidden = false;
             }
         }
-        if (typeof context.hidden === 'boolean') {
+        if (typeof context.hidden === "boolean") {
             this._state.hidden = context.hidden;
         }
-        if (typeof context.later === 'boolean') {
+        if (typeof context.later === "boolean") {
             this._state.later = context.later;
         }
-        if (typeof context.entitlement === 'number') {
+        if (typeof context.entitlement === "number") {
             this._state.entitlement = context.entitlement;
             this._state.organisations = context.organisations;
             this._state.sku = context.sku;
             if (this._state.entitlement === ChatEntitlement.Free || isProUser(this._state.entitlement)) {
                 this._state.registered = true;
-            }
-            else if (this._state.entitlement === ChatEntitlement.Available) {
+            } else if (this._state.entitlement === ChatEntitlement.Available) {
                 this._state.registered = false;
             }
         }
         if (isAnonymous(this.configurationService, this._state.entitlement, this._state)) {
-            this._state.sku = 'no_auth_limited_copilot';
+            this._state.sku = "no_auth_limited_copilot";
         }
         if (oldState === JSON.stringify(this._state)) {
             return;
@@ -846,7 +814,9 @@ let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
         this.businessContextKey.set(state.entitlement === ChatEntitlement.Business);
         this.enterpriseContextKey.set(state.entitlement === ChatEntitlement.Enterprise);
         this.organisationsContextKey.set(state.organisations);
-        this.isInternalContextKey.set(Boolean(state.organisations?.some(org => org === 'github' || org === 'microsoft' || org === 'ms-copilot' || org === 'MicrosoftCopilot')));
+        this.isInternalContextKey.set(Boolean(state.organisations?.some(
+            org => org === "github" || org === "microsoft" || org === "ms-copilot" || org === "MicrosoftCopilot"
+        )));
         this.skuContextKey.set(state.sku);
         this.hiddenContext.set(!!state.hidden);
         this.laterContext.set(!!state.later);
@@ -859,7 +829,9 @@ let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
         this._onDidChange.fire();
     }
     suspend() {
-        this.suspendedState = { ...this._state };
+        this.suspendedState = {
+            ...this._state
+        };
         this.updateBarrier = ( new Barrier());
     }
     resume() {
@@ -868,12 +840,6 @@ let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
         this.updateBarrier = undefined;
     }
 };
-ChatEntitlementContext = ChatEntitlementContext_1 = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ITelemetryService))
-], ChatEntitlementContext));
+ChatEntitlementContext = ChatEntitlementContext_1 = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, IStorageService)), ( __param(2, ILogService)), ( __param(3, IConfigurationService)), ( __param(4, ITelemetryService))], ChatEntitlementContext));
 
-export { ChatEntitlement, ChatEntitlementContext, ChatEntitlementContextKeys, ChatEntitlementRequests, ChatEntitlementService, isProUser };
+export { ChatEntitlement, ChatEntitlementContext, ChatEntitlementContextKeys, ChatEntitlementRequests, ChatEntitlementService, getChatPlanName, isProUser };