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

package/vscode/src/vs/workbench/services/accounts/browser/defaultAccount.js

@@ -1,1580 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { distinct } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { ThrottledDelayer, RunOnceScheduler, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { getErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
-import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { isUndefined, isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-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 { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
-import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
-import { MANAGED_SETTINGS_UPDATE_REQUIRED_ERROR_CODE } 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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { resolveForceRemoteSettingsRefresh } from '@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/copilotManagedSettings';
-import { INativeManagedSettingsService, IFileManagedSettingsService } from '@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/copilotManagedSettings.service';
-import { MANAGED_SETTINGS_FRESHNESS_NOT_REQUIRED, ManagedSettingsFreshnessState, isManagedSettingsFreshnessBlocking, ManagedSettingsFreshnessFailure, isManagedSettingsFreshnessSatisfiedFor } from '@codingame/monaco-vscode-api/vscode/vs/platform/policy/common/managedSettingsFreshness';
-import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
-import { asJson, isSuccess, isClientError, asText, readHeader, retryAfterFromHeaders } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
-import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
-import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
-import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
-import { IAuthenticationService, IAuthenticationExtensionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
-import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
-import { appendManagedSettingsClientIdentity, adaptManagedSettings, parseManagedSettingsCompatibilityError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/accounts/browser/managedSettings';
-
-const DEFAULT_ACCOUNT_SIGN_IN_COMMAND = "workbench.actions.accounts.signIn";
-var DefaultAccountStatus;
-(function(DefaultAccountStatus) {
-    DefaultAccountStatus["Uninitialized"] = "uninitialized";
-    DefaultAccountStatus["Unavailable"] = "unavailable";
-    DefaultAccountStatus["Available"] = "available";
-})(DefaultAccountStatus || (DefaultAccountStatus = {}));
-const CONTEXT_DEFAULT_ACCOUNT_STATE = ( new RawContextKey("defaultAccountStatus", DefaultAccountStatus.Uninitialized));
-const CACHED_POLICY_DATA_KEY = "defaultAccount.cachedPolicyData";
-const ACCOUNT_DATA_POLL_INTERVAL_MS = 60 * 60 * 1000;
-const MANAGED_SETTINGS_REQUEST_TIMEOUT_MS = 5000;
-function toDefaultAccountConfig(defaultChatAgent) {
-    return {
-        preferredExtensions: [defaultChatAgent.chatExtensionId, defaultChatAgent.extensionId],
-        authenticationProvider: {
-            default: {
-                id: defaultChatAgent.provider.default.id,
-                name: defaultChatAgent.provider.default.name
-            },
-            enterprise: {
-                id: defaultChatAgent.provider.enterprise.id,
-                name: defaultChatAgent.provider.enterprise.name
-            },
-            enterpriseProviderConfig: `${defaultChatAgent.completionsAdvancedSetting}.authProvider`,
-            enterpriseProviderUriSetting: defaultChatAgent.providerUriSetting,
-            scopes: defaultChatAgent.providerScopes
-        },
-        entitlementUrl: defaultChatAgent.entitlementUrl,
-        tokenEntitlementUrl: defaultChatAgent.tokenEntitlementUrl,
-        mcpRegistryDataUrl: defaultChatAgent.mcpRegistryDataUrl,
-        managedSettingsUrl: defaultChatAgent.managedSettingsUrl
-    };
-}
-let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
-    get defaultAccount() {
-        return this._defaultAccount?.defaultAccount ?? null;
-    }
-    get policyData() {
-        return this._policyData?.policyData ?? null;
-    }
-    get copilotTokenInfo() {
-        return this._copilotTokenInfo;
-    }
-    get managedSettingsFetchStatus() {
-        return this._managedSettingsFetchStatus;
-    }
-    get managedSettingsFetchedAt() {
-        return this._policyData?.managedSettingsFetchedAt ?? null;
-    }
-    get managedSettingsRawResponse() {
-        return this._managedSettingsRawResponse;
-    }
-    get managedSettingsCompatibilityError() {
-        return this._managedSettingsCompatibilityError;
-    }
-    get managedSettingsFreshness() {
-        return this._managedSettingsFreshness;
-    }
-    constructor(
-        defaultAccountConfig,
-        configurationService,
-        authenticationService,
-        authenticationExtensionsService,
-        telemetryService,
-        extensionService,
-        requestService,
-        logService,
-        environmentService,
-        productService,
-        contextKeyService,
-        storageService,
-        hostService,
-        commandService,
-        nativeManagedSettingsService,
-        fileManagedSettingsService
-    ) {
-        super();
-        this.defaultAccountConfig = defaultAccountConfig;
-        this.configurationService = configurationService;
-        this.authenticationService = authenticationService;
-        this.authenticationExtensionsService = authenticationExtensionsService;
-        this.telemetryService = telemetryService;
-        this.extensionService = extensionService;
-        this.requestService = requestService;
-        this.logService = logService;
-        this.environmentService = environmentService;
-        this.productService = productService;
-        this.storageService = storageService;
-        this.hostService = hostService;
-        this.commandService = commandService;
-        this.nativeManagedSettingsService = nativeManagedSettingsService;
-        this.fileManagedSettingsService = fileManagedSettingsService;
-        this._defaultAccount = null;
-        this._policyData = null;
-        this._copilotTokenInfo = null;
-        this._managedSettingsFetchStatus = null;
-        this._managedSettingsRawResponse = null;
-        this._managedSettingsCompatibilityError = null;
-        this._managedSettingsFreshness = MANAGED_SETTINGS_FRESHNESS_NOT_REQUIRED;
-        this._onDidChangeDefaultAccount = this._register(( new Emitter()));
-        this.onDidChangeDefaultAccount = this._onDidChangeDefaultAccount.event;
-        this._onDidChangePolicyData = this._register(( new Emitter()));
-        this.onDidChangePolicyData = this._onDidChangePolicyData.event;
-        this._onDidChangeCopilotTokenInfo = this._register(( new Emitter()));
-        this.onDidChangeCopilotTokenInfo = this._onDidChangeCopilotTokenInfo.event;
-        this._onDidChangeManagedSettingsCompatibilityError = this._register(( new Emitter()));
-        this.onDidChangeManagedSettingsCompatibilityError = this._onDidChangeManagedSettingsCompatibilityError.event;
-        this._onDidChangeManagedSettingsFreshness = this._register(( new Emitter()));
-        this.onDidChangeManagedSettingsFreshness = this._onDidChangeManagedSettingsFreshness.event;
-        this.initialized = false;
-        this.updateThrottler = this._register(( new ThrottledDelayer(100)));
-        this.accountDataPollScheduler = this._register(( new RunOnceScheduler(() => this.refetchDefaultAccount(), ACCOUNT_DATA_POLL_INTERVAL_MS)));
-        this.failedManagedSettingsFreshness = ( new Map());
-        this._rateLimitBackoffUntil = 0;
-        this.accountStatusContext = CONTEXT_DEFAULT_ACCOUNT_STATE.bindTo(contextKeyService);
-        const cachedAccountData = this.getCachedAccountData();
-        this._policyData = cachedAccountData?.accountPolicyData ?? null;
-        this._copilotTokenInfo = cachedAccountData?.copilotTokenInfo ?? null;
-        this._managedSettingsCompatibilityError = cachedAccountData?.accountPolicyData.managedSettingsCompatibilityError ?? null;
-        this.updateManagedSettingsFreshnessRequirement(
-            this.nativeManagedSettingsService.managedSettings,
-            this.getCachedServerManagedSettings(this.getDefaultAccountAuthenticationProvider()),
-            this.fileManagedSettingsService.managedSettings
-        );
-        this._register(
-            this.nativeManagedSettingsService.onDidChangeManagedSettings(() => this.onManagedSettingsSourceChanged())
-        );
-        this._register(
-            this.fileManagedSettingsService.onDidChangeManagedSettings(() => this.onManagedSettingsSourceChanged())
-        );
-        this.initPromise = this.init().finally(() => {
-            this.telemetryService.publicLog2("defaultaccount:status", {
-                status: this.defaultAccount ? "available" : "unavailable",
-                initial: true
-            });
-            this.initialized = true;
-        });
-    }
-    getCachedAccountData() {
-        const cached = this.storageService.get(CACHED_POLICY_DATA_KEY, StorageScope.APPLICATION);
-        if (cached) {
-            try {
-                const parsed = JSON.parse(cached);
-                const {
-                    accountId,
-                    policyData,
-                    tokenEntitlementsFetchedAt,
-                    mcpRegistryDataFetchedAt,
-                    copilotTokenInfo
-                } = parsed;
-                if (accountId && policyData) {
-                    this.logService.debug(
-                        "[DefaultAccount] Initializing with cached policy data (migrating old format)"
-                    );
-                    const result = {
-                        accountPolicyData: {
-                            accountId,
-                            policyData,
-                            tokenEntitlementsFetchedAt,
-                            mcpRegistryDataFetchedAt
-                        },
-                        copilotTokenInfo
-                    };
-                    this.storageService.store(
-                        CACHED_POLICY_DATA_KEY,
-                        JSON.stringify(result),
-                        StorageScope.APPLICATION,
-                        StorageTarget.MACHINE
-                    );
-                    return result;
-                }
-                const {
-                    accountPolicyData,
-                    copilotTokenInfo: wrappedCopilotTokenInfo
-                } = parsed;
-                if (accountPolicyData?.accountId && accountPolicyData?.policyData) {
-                    this.logService.debug("[DefaultAccount] Initializing with cached policy data");
-                    return {
-                        accountPolicyData,
-                        copilotTokenInfo: wrappedCopilotTokenInfo
-                    };
-                }
-            } catch (error) {
-                this.logService.error(
-                    "[DefaultAccount] Failed to parse cached policy data",
-                    getErrorMessage(error)
-                );
-            }
-        }
-        return null;
-    }
-    async init() {
-        if (isWeb && !this.environmentService.remoteAuthority && !this.environmentService.isSessionsWindow) {
-            this.logService.debug("[DefaultAccount] Running in web without remote, skipping initialization");
-            return;
-        }
-        await this.whenDefaultAccountAuthenticationProviderAvailable();
-        this.logService.debug("[DefaultAccount] Starting initialization");
-        await this.doUpdateDefaultAccount();
-        this.logService.debug("[DefaultAccount] Initialization complete");
-        this._register(this.onDidChangeDefaultAccount(account => {
-            this.telemetryService.publicLog2("defaultaccount:status", {
-                status: account ? "available" : "unavailable",
-                initial: false
-            });
-        }));
-        this._register(this.authenticationService.onDidChangeSessions(e => {
-            const defaultAccountProvider = this.getDefaultAccountAuthenticationProvider();
-            if (e.providerId !== defaultAccountProvider.id) {
-                return;
-            }
-            const added = e.event.added?.length ?? 0;
-            const removed = e.event.removed?.length ?? 0;
-            const changed = e.event.changed?.length ?? 0;
-            const currentSessionRemoved = this.defaultAccount !== null && (e.event.removed?.some(session => session.id === this.defaultAccount?.sessionId) ?? false);
-            const hasReplacementCandidates = added > 0 || changed > 0;
-            const clearDefaultAccount = currentSessionRemoved && !hasReplacementCandidates;
-            const message = `[DefaultAccount] Authentication sessions changed: added=${added}, removed=${removed}, changed=${changed}, currentSessionRemoved=${currentSessionRemoved}, hasReplacementCandidates=${hasReplacementCandidates}, decision=${clearDefaultAccount ? "clear" : "reconcile"}`;
-            if (currentSessionRemoved || (added > 0 && removed > 0)) {
-                this.logService.info(message);
-            } else {
-                this.logService.trace(message);
-            }
-            if (clearDefaultAccount) {
-                this.setDefaultAccount(null);
-            } else {
-                this.updateDefaultAccount();
-            }
-        }));
-        this._register(
-            this.authenticationExtensionsService.onDidChangeAccountPreference(async e => {
-                const defaultAccountProvider = this.getDefaultAccountAuthenticationProvider();
-                if (e.providerId !== defaultAccountProvider.id) {
-                    return;
-                }
-                this.logService.debug(
-                    "[DefaultAccount] Account preference changed for default account provider, updating default account"
-                );
-                this.updateDefaultAccount();
-            })
-        );
-        this._register(this.authenticationService.onDidRegisterAuthenticationProvider(e => {
-            const defaultAccountProvider = this.getDefaultAccountAuthenticationProvider();
-            if (e.id !== defaultAccountProvider.id) {
-                return;
-            }
-            this.logService.debug(
-                "[DefaultAccount] Default account provider registered, updating default account"
-            );
-            this.updateDefaultAccount();
-        }));
-        this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(e => {
-            const defaultAccountProvider = this.getDefaultAccountAuthenticationProvider();
-            if (e.id !== defaultAccountProvider.id) {
-                return;
-            }
-            this.logService.debug(
-                "[DefaultAccount] Default account provider unregistered, updating default account"
-            );
-            this.updateDefaultAccount();
-        }));
-        this._register(this.hostService.onDidChangeFocus(focused => {
-            if (focused) {
-                this.refetchDefaultAccount();
-            }
-        }));
-    }
-    async whenDefaultAccountAuthenticationProviderAvailable() {
-        const provider = this.getDefaultAccountAuthenticationProvider();
-        this.logService.debug(
-            "[DefaultAccount] Waiting for default account authentication provider to be available."
-        );
-        const disposables = ( new DisposableStore());
-        try {
-            await ( new Promise(resolve => {
-                if (this.isAccountProviderAvailable(provider)) {
-                    this.logService.debug(
-                        "[DefaultAccount] Default account authentication provider is now available."
-                    );
-                    resolve();
-                    return;
-                }
-                disposables.add(Event.any(
-                    this.authenticationService.onDidChangeDeclaredProviders,
-                    this.authenticationService.onDidRegisterAuthenticationProvider
-                )(() => {
-                    if (this.isAccountProviderAvailable(provider)) {
-                        this.logService.debug(
-                            "[DefaultAccount] Default account authentication provider is now available."
-                        );
-                        resolve();
-                    }
-                }));
-                if (this.environmentService.remoteAuthority) {
-                    void this.authenticationService.getSessions(provider.id, undefined, {}, true);
-                }
-                this.extensionService.whenInstalledExtensionsRegistered().then(() => {
-                    disposables.dispose();
-                    this.logService.debug("[DefaultAccount] Installed extensions registered.");
-                    resolve();
-                }, error => {
-                    this.logService.error(
-                        "[DefaultAccount] Error while waiting for installed extensions to be registered",
-                        getErrorMessage(error)
-                    );
-                    resolve();
-                });
-            }));
-        } finally {
-            disposables.dispose();
-        }
-    }
-    async refresh(options) {
-        if (!this.initialized) {
-            await this.initPromise;
-            return this.defaultAccount;
-        }
-        this.logService.debug("[DefaultAccount] Refreshing default account");
-        await this.updateDefaultAccount(options);
-        return this.defaultAccount;
-    }
-    async refetchDefaultAccount() {
-        if (this.accountDataPollScheduler.isScheduled()) {
-            this.accountDataPollScheduler.cancel();
-        }
-        if (!this.hostService.hasFocus || !this._defaultAccount) {
-            this.scheduleAccountDataPoll();
-            this.logService.debug(
-                "[DefaultAccount] Skipping refetching default account. Host is not focused or default account is not set"
-            );
-            return;
-        }
-        this.logService.debug("[DefaultAccount] Refetching default account");
-        await this.updateDefaultAccount();
-    }
-    async updateDefaultAccount(options) {
-        await this.updateThrottler.trigger(() => this.doUpdateDefaultAccount(options));
-    }
-    async doUpdateDefaultAccount(options) {
-        const currentSessionId = this.defaultAccount?.sessionId;
-        try {
-            const defaultAccount = await this.fetchDefaultAccount(options);
-            if (currentSessionId && this.defaultAccount?.sessionId !== currentSessionId) {
-                this.logService.info(
-                    "[DefaultAccount] Discarding default account update because the current session changed while the update was in progress"
-                );
-                return;
-            }
-            this.setDefaultAccount(defaultAccount);
-            this.scheduleAccountDataPoll();
-        } catch (error) {
-            this.logService.error(
-                "[DefaultAccount] Error while updating default account",
-                getErrorMessage(error)
-            );
-            this.blockPendingManagedSettingsFreshness();
-        }
-    }
-    async fetchDefaultAccount(options) {
-        const defaultAccountProvider = this.getDefaultAccountAuthenticationProvider();
-        this.logService.debug("[DefaultAccount] Default account provider ID:", defaultAccountProvider.id);
-        const managedSettingsSources = await this.initializeManagedSettingsSources();
-        const refreshRequirement = resolveForceRemoteSettingsRefresh(
-            managedSettingsSources.nativeMdm,
-            this.getCachedServerManagedSettings(defaultAccountProvider),
-            managedSettingsSources.file
-        );
-        if (!refreshRequirement.effective) {
-            this.setManagedSettingsFreshness(MANAGED_SETTINGS_FRESHNESS_NOT_REQUIRED);
-        }
-        if (!this.isAccountProviderAvailable(defaultAccountProvider)) {
-            this.logService.info(
-                `[DefaultAccount] Authentication provider is not available.`,
-                defaultAccountProvider
-            );
-            this.blockManagedSettingsFreshnessWithoutToken(refreshRequirement);
-            return null;
-        }
-        return await this.getDefaultAccountForAuthenticationProvider(
-            defaultAccountProvider,
-            managedSettingsSources,
-            refreshRequirement,
-            options
-        );
-    }
-    isAccountProviderAvailable(accountProvider) {
-        return ( this.authenticationService.declaredProviders.some(p => p.id === accountProvider.id)) || this.authenticationService.isAuthenticationProviderRegistered(accountProvider.id);
-    }
-    setDefaultAccount(account) {
-        if (equals(this._defaultAccount, account)) {
-            return;
-        }
-        this.logService.trace("[DefaultAccount] Updating default account:", account);
-        if (account) {
-            this._defaultAccount = account;
-            this.setCopilotTokenInfo(account.copilotTokenInfo);
-            this.setPolicyData(account.policyData);
-            this.setManagedSettingsCompatibilityError(account.policyData?.managedSettingsCompatibilityError ?? null);
-            this._onDidChangeDefaultAccount.fire(this._defaultAccount.defaultAccount);
-            this.accountStatusContext.set(DefaultAccountStatus.Available);
-            this.logService.debug("[DefaultAccount] Account status set to Available");
-        } else {
-            this._defaultAccount = null;
-            const refreshRequirement = resolveForceRemoteSettingsRefresh(
-                this.nativeManagedSettingsService.managedSettings,
-                this.getCachedServerManagedSettings(this.getDefaultAccountAuthenticationProvider()),
-                this.fileManagedSettingsService.managedSettings
-            );
-            this.blockManagedSettingsFreshnessWithoutToken(refreshRequirement);
-            const retainedPolicyData = this._managedSettingsFreshness.state !== ManagedSettingsFreshnessState.NotRequired && isManagedSettingsFreshnessBlocking(this._managedSettingsFreshness) && this._managedSettingsFreshness.source === "server" ? this._policyData : null;
-            this.setPolicyData(retainedPolicyData);
-            this.setManagedSettingsCompatibilityError(null);
-            this.setCopilotTokenInfo(null);
-            this._onDidChangeDefaultAccount.fire(null);
-            this.accountDataPollScheduler.cancel();
-            this.accountStatusContext.set(DefaultAccountStatus.Unavailable);
-            this.logService.debug("[DefaultAccount] Account status set to Unavailable");
-        }
-    }
-    setPolicyData(accountPolicyData) {
-        if (equals(this._policyData, accountPolicyData)) {
-            return;
-        }
-        this._policyData = accountPolicyData;
-        this.cachePolicyData(accountPolicyData);
-        this._onDidChangePolicyData.fire(this._policyData?.policyData ?? null);
-    }
-    setManagedSettingsCompatibilityError(error) {
-        if (equals(this._managedSettingsCompatibilityError, error)) {
-            return;
-        }
-        this._managedSettingsCompatibilityError = error;
-        this._onDidChangeManagedSettingsCompatibilityError.fire(error);
-    }
-    setManagedSettingsFreshness(freshness) {
-        if (equals(this._managedSettingsFreshness, freshness)) {
-            return;
-        }
-        this._managedSettingsFreshness = freshness;
-        this._onDidChangeManagedSettingsFreshness.fire(freshness);
-    }
-    blockPendingManagedSettingsFreshness() {
-        if (this._managedSettingsFreshness.state === ManagedSettingsFreshnessState.Pending) {
-            this.setManagedSettingsFreshness({
-                ...this._managedSettingsFreshness,
-                state: ManagedSettingsFreshnessState.Blocked,
-                failure: ManagedSettingsFreshnessFailure.Network
-            });
-        }
-    }
-    updateManagedSettingsFreshnessRequirement(nativeMdm, server, file) {
-        const requirement = resolveForceRemoteSettingsRefresh(nativeMdm, server, file);
-        this.setManagedSettingsFreshness(requirement.effective ? {
-            state: ManagedSettingsFreshnessState.Pending,
-            source: requirement.source
-        } : MANAGED_SETTINGS_FRESHNESS_NOT_REQUIRED);
-    }
-    onManagedSettingsSourceChanged() {
-        if (this.initialized) {
-            void this.updateDefaultAccount();
-        }
-    }
-    async initializeManagedSettingsSources() {
-        let nativeMdm = this.nativeManagedSettingsService.managedSettings;
-        try {
-            nativeMdm = await this.nativeManagedSettingsService.initialize();
-        } catch (error) {
-            this.logService.warn(
-                "[DefaultAccount] Failed to initialize native managed settings before resolving forceRemoteSettingsRefresh; using available values",
-                getErrorMessage(error)
-            );
-        }
-        let file = this.fileManagedSettingsService.managedSettings;
-        try {
-            file = await this.fileManagedSettingsService.initialize();
-        } catch (error) {
-            this.logService.warn(
-                "[DefaultAccount] Failed to initialize file managed settings before resolving forceRemoteSettingsRefresh; using available values",
-                getErrorMessage(error)
-            );
-        }
-        return {
-            nativeMdm,
-            file
-        };
-    }
-    blockManagedSettingsFreshnessWithoutToken(requirement) {
-        if (requirement.effective) {
-            this.setManagedSettingsFreshness({
-                state: ManagedSettingsFreshnessState.Blocked,
-                source: requirement.source,
-                failure: ManagedSettingsFreshnessFailure.NoToken
-            });
-        }
-    }
-    getCachedServerManagedSettings(authenticationProvider) {
-        return this.getScopedServerManagedSettings(
-            this._policyData ?? undefined,
-            authenticationProvider,
-            this._policyData?.accountId
-        );
-    }
-    getScopedServerManagedSettings(accountPolicyData, authenticationProvider, accountId) {
-        if (!accountPolicyData || accountPolicyData.accountId !== accountId) {
-            return undefined;
-        }
-        const scope = accountPolicyData.managedSettingsScope;
-        const managedSettingsUrl = this.getManagedSettingsUrl();
-        if (scope && (scope.accountId !== accountId || scope.authenticationProviderId !== authenticationProvider.id || (managedSettingsUrl ? scope.endpointOrigin !== this.createManagedSettingsFreshnessScope(scope.accountId, authenticationProvider.id, managedSettingsUrl).endpointOrigin : false))) {
-            return undefined;
-        }
-        return accountPolicyData.policyData.managedSettings;
-    }
-    setCopilotTokenInfo(copilotTokenInfo) {
-        if (equals(this._copilotTokenInfo, copilotTokenInfo)) {
-            return;
-        }
-        this._copilotTokenInfo = copilotTokenInfo;
-        this._onDidChangeCopilotTokenInfo.fire(this._copilotTokenInfo);
-    }
-    cachePolicyData(accountPolicyData) {
-        if (accountPolicyData) {
-            this.logService.debug(
-                "[DefaultAccount] Caching policy data for account:",
-                accountPolicyData.accountId
-            );
-            const cachedAccountData = {
-                accountPolicyData,
-                copilotTokenInfo: this._copilotTokenInfo ?? undefined
-            };
-            this.storageService.store(
-                CACHED_POLICY_DATA_KEY,
-                JSON.stringify(cachedAccountData),
-                StorageScope.APPLICATION,
-                StorageTarget.MACHINE
-            );
-        } else {
-            this.logService.debug("[DefaultAccount] Removing cached policy data");
-            this.storageService.remove(CACHED_POLICY_DATA_KEY, StorageScope.APPLICATION);
-        }
-    }
-    scheduleAccountDataPoll() {
-        if (!this._defaultAccount) {
-            return;
-        }
-        this.accountDataPollScheduler.schedule(ACCOUNT_DATA_POLL_INTERVAL_MS);
-    }
-    extractFromToken(token) {
-        const result = ( new Map());
-        const firstPart = token?.split(":")[0];
-        const fields = firstPart?.split(";");
-        for (const field of fields) {
-            const [key, value] = field.split("=");
-            result.set(key, value);
-        }
-        this.logService.debug(
-            `[DefaultAccount] extractFromToken: ${JSON.stringify(Object.fromEntries(result))}`
-        );
-        return result;
-    }
-    async getDefaultAccountForAuthenticationProvider(
-        authenticationProvider,
-        managedSettingsSources,
-        refreshRequirement,
-        options
-    ) {
-        try {
-            this.logService.debug(
-                "[DefaultAccount] Getting Default Account from authenticated sessions for provider:",
-                authenticationProvider.id
-            );
-            const sessions = await this.findMatchingProviderSession(
-                authenticationProvider.id,
-                this.defaultAccountConfig.authenticationProvider.scopes
-            );
-            if (!sessions?.length) {
-                this.logService.debug(
-                    "[DefaultAccount] No matching session found for provider:",
-                    authenticationProvider.id
-                );
-                this.blockManagedSettingsFreshnessWithoutToken(refreshRequirement);
-                return null;
-            }
-            return this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, options, managedSettingsSources);
-        } catch (error) {
-            this.logService.error(
-                "[DefaultAccount] Failed to get default account for provider:",
-                authenticationProvider.id,
-                getErrorMessage(error)
-            );
-            this.blockManagedSettingsFreshnessWithoutToken(refreshRequirement);
-            return null;
-        }
-    }
-    async getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, options, managedSettingsSources) {
-        try {
-            const accountId = sessions[0].account.id;
-            const accountPolicyData = this._policyData?.accountId === accountId ? this._policyData : undefined;
-            const sources = managedSettingsSources ?? (await this.initializeManagedSettingsSources());
-            const requirement = resolveForceRemoteSettingsRefresh(
-                sources.nativeMdm,
-                this.getScopedServerManagedSettings(accountPolicyData, authenticationProvider, accountId),
-                sources.file
-            );
-            const managedSettingsUrl = this.getManagedSettingsUrl();
-            const scope = managedSettingsUrl ? this.createManagedSettingsFreshnessScope(accountId, authenticationProvider.id, managedSettingsUrl) : undefined;
-            if (!requirement.effective) {
-                this.setManagedSettingsFreshness(MANAGED_SETTINGS_FRESHNESS_NOT_REQUIRED);
-            } else if ((!scope || !isManagedSettingsFreshnessSatisfiedFor(this._managedSettingsFreshness, scope) || options?.forceRefresh) && this.canRequestManagedSettings(options, scope)) {
-                this.setManagedSettingsFreshness({
-                    state: ManagedSettingsFreshnessState.Pending,
-                    source: requirement.source,
-                    scope
-                });
-            }
-            const entitlementsResult = await this.getEntitlements(sessions, accountPolicyData, options);
-            const entitlementsData = entitlementsResult?.data;
-            const entitlementsFetchedAt = entitlementsResult?.fetchedAt;
-            const [tokenEntitlementsResult, managedSettingsResult] = await Promise.all([
-                entitlementsData?.chat_enabled ? this.getTokenEntitlements(sessions, accountPolicyData, options) : undefined,
-                entitlementsData?.chat_enabled || requirement.effective ? this.getManagedSettings(
-                    sessions,
-                    accountPolicyData,
-                    options,
-                    authenticationProvider,
-                    sources,
-                    requirement
-                ) : undefined
-            ]);
-            const tokenEntitlementsFetchedAt = tokenEntitlementsResult?.fetchedAt;
-            const managedSettingsFetchedAt = managedSettingsResult?.fetchedAt;
-            const managedSettingsScope = managedSettingsResult?.scope ?? accountPolicyData?.managedSettingsScope;
-            const managedSettingsCompatibilityError = managedSettingsResult ? managedSettingsResult.compatibilityError : this._managedSettingsCompatibilityError;
-            let mcpRegistryDataFetchedAt;
-            let policyData = accountPolicyData?.policyData ? {
-                ...accountPolicyData.policyData
-            } : undefined;
-            if (entitlementsData) {
-                policyData = policyData ?? {};
-                policyData.cloud_session_storage_enabled = entitlementsData.cloud_session_storage_enabled;
-            }
-            if (tokenEntitlementsResult?.data) {
-                const tokenEntitlementsData = tokenEntitlementsResult.data;
-                policyData = policyData ?? {};
-                policyData.chat_agent_enabled = tokenEntitlementsData.policyData.chat_agent_enabled;
-                policyData.chat_preview_features_enabled = tokenEntitlementsData.policyData.chat_preview_features_enabled;
-                policyData.mcp = tokenEntitlementsData.policyData.mcp;
-                if (policyData.mcp) {
-                    const mcpRegistryResult = await this.getMcpRegistryProvider(sessions, accountPolicyData, options);
-                    mcpRegistryDataFetchedAt = mcpRegistryResult?.fetchedAt;
-                    policyData.mcpRegistryUrl = mcpRegistryResult?.data?.url;
-                    policyData.mcpAccess = mcpRegistryResult?.data?.registry_access;
-                } else {
-                    policyData.mcpRegistryUrl = undefined;
-                    policyData.mcpAccess = undefined;
-                }
-            }
-            if (managedSettingsResult?.data) {
-                policyData = {
-                    ...(policyData ?? {}),
-                    ...managedSettingsResult.data
-                };
-            }
-            const defaultAccount = {
-                authenticationProvider,
-                accountName: sessions[0].account.label,
-                sessionId: sessions[0].id,
-                enterprise: authenticationProvider.enterprise || sessions[0].account.label.includes("_"),
-                entitlementsData
-            };
-            this.logService.debug(
-                "[DefaultAccount] Successfully created default account for provider:",
-                authenticationProvider.id
-            );
-            const accountPolicyResult = policyData || entitlementsFetchedAt ? {
-                accountId,
-                policyData: policyData ?? {},
-                entitlementsFetchedAt,
-                tokenEntitlementsFetchedAt,
-                mcpRegistryDataFetchedAt,
-                managedSettingsFetchedAt,
-                managedSettingsScope,
-                managedSettingsCompatibilityError: managedSettingsCompatibilityError ?? undefined
-            } : null;
-            return {
-                defaultAccount,
-                accountId,
-                policyData: accountPolicyResult,
-                copilotTokenInfo: tokenEntitlementsResult?.data?.copilotTokenInfo ?? null
-            };
-        } catch (error) {
-            this.logService.error(
-                "[DefaultAccount] Failed to create default account for provider:",
-                authenticationProvider.id,
-                getErrorMessage(error)
-            );
-            this.blockPendingManagedSettingsFreshness();
-            return null;
-        }
-    }
-    async findMatchingProviderSession(authProviderId, allScopes) {
-        const sessions = await this.getSessions(authProviderId);
-        const matchingSessions = sessions.filter(session => {
-            this.logService.debug("[DefaultAccount] Checking session with scopes", session.scopes);
-            return ( allScopes.some(scopes => this.scopesMatch(session.scopes, scopes)));
-        });
-        return matchingSessions.length > 0 ? matchingSessions : undefined;
-    }
-    async getSessions(authProviderId) {
-        for (let attempt = 1; attempt <= 3; attempt++) {
-            try {
-                let preferredAccount;
-                let preferredAccountName;
-                for (const preferredExtension of this.defaultAccountConfig.preferredExtensions) {
-                    preferredAccountName = this.authenticationExtensionsService.getAccountPreference(preferredExtension, authProviderId);
-                    if (preferredAccountName) {
-                        break;
-                    }
-                }
-                for (const account of await this.authenticationService.getAccounts(authProviderId)) {
-                    if (account.label === preferredAccountName) {
-                        preferredAccount = account;
-                        break;
-                    }
-                }
-                return await this.authenticationService.getSessions(authProviderId, undefined, {
-                    account: preferredAccount
-                }, true);
-            } catch (error) {
-                this.logService.warn(
-                    `[DefaultAccount] Attempt ${attempt} to get sessions failed:`,
-                    getErrorMessage(error)
-                );
-                if (attempt === 3) {
-                    throw error;
-                }
-                await timeout(500);
-            }
-        }
-        throw ( new Error("Unable to get sessions after multiple attempts"));
-    }
-    scopesMatch(scopes, expectedScopes) {
-        return expectedScopes.every(scope => scopes.includes(scope));
-    }
-    async getTokenEntitlements(sessions, accountPolicyData, options) {
-        if (!options?.forceRefresh && accountPolicyData?.tokenEntitlementsFetchedAt && !this.isDataStale(accountPolicyData.tokenEntitlementsFetchedAt)) {
-            this.logService.debug("[DefaultAccount] Using last fetched token entitlements data");
-            return {
-                data: {
-                    policyData: accountPolicyData.policyData,
-                    copilotTokenInfo: this._copilotTokenInfo ?? {}
-                },
-                fetchedAt: accountPolicyData.tokenEntitlementsFetchedAt
-            };
-        }
-        const data = await this.requestTokenEntitlements(sessions);
-        return {
-            data,
-            fetchedAt: Date.now()
-        };
-    }
-    async requestTokenEntitlements(sessions) {
-        const tokenEntitlementsUrl = this.getTokenEntitlementUrl();
-        if (!tokenEntitlementsUrl) {
-            this.logService.debug("[DefaultAccount] No token entitlements URL found");
-            return undefined;
-        }
-        this.logService.debug("[DefaultAccount] Fetching token entitlements from:", tokenEntitlementsUrl);
-        const response = await this.request(
-            tokenEntitlementsUrl,
-            "GET",
-            undefined,
-            sessions,
-            CancellationToken.None,
-            "defaultAccount.tokenEntitlements"
-        );
-        if (!response) {
-            return undefined;
-        }
-        if (response.res.statusCode && response.res.statusCode !== 200) {
-            this.logService.trace(
-                `[DefaultAccount] unexpected status code ${response.res.statusCode} while fetching token entitlements`
-            );
-            return undefined;
-        }
-        try {
-            const chatData = await asJson(response);
-            if (chatData) {
-                const tokenMap = this.extractFromToken(chatData.token);
-                return {
-                    policyData: {
-                        chat_preview_features_enabled: tokenMap.get("editor_preview_features") !== "0",
-                        chat_agent_enabled: tokenMap.get("agent_mode") !== "0",
-                        mcp: tokenMap.get("mcp") === "1"
-                    },
-                    copilotTokenInfo: {
-                        sn: tokenMap.get("sn"),
-                        fcv1: tokenMap.get("fcv1")
-                    }
-                };
-            }
-            this.logService.error("Failed to fetch token entitlements", "No data returned");
-        } catch (error) {
-            this.logService.error("Failed to fetch token entitlements", getErrorMessage(error));
-        }
-        return undefined;
-    }
-    async getEntitlements(sessions, accountPolicyData, options) {
-        const accountId = sessions[0].account.id;
-        const existingData = this._defaultAccount?.accountId === accountId ? this._defaultAccount?.defaultAccount.entitlementsData : undefined;
-        if (!options?.forceRefresh && !options?.refreshEntitlements && existingData && accountPolicyData?.entitlementsFetchedAt && !this.isDataStale(accountPolicyData.entitlementsFetchedAt)) {
-            this.logService.debug("[DefaultAccount] Using last fetched entitlements data");
-            return {
-                data: existingData,
-                fetchedAt: accountPolicyData.entitlementsFetchedAt
-            };
-        }
-        const entitlementUrl = this.getEntitlementUrl();
-        if (!entitlementUrl) {
-            this.logService.debug("[DefaultAccount] No chat entitlements URL found");
-            return {
-                data: undefined,
-                fetchedAt: undefined
-            };
-        }
-        this.logService.debug("[DefaultAccount] Fetching entitlements from:", entitlementUrl);
-        const response = await this.request(
-            entitlementUrl,
-            "GET",
-            undefined,
-            sessions,
-            CancellationToken.None,
-            "defaultAccount.entitlements"
-        );
-        if (!response) {
-            return {
-                data: undefined,
-                fetchedAt: Date.now()
-            };
-        }
-        if (response.res.statusCode && response.res.statusCode !== 200) {
-            this.logService.trace(
-                `[DefaultAccount] unexpected status code ${response.res.statusCode} while fetching entitlements`
-            );
-            const data =
-            (
-            response.res.statusCode === 401 || response.res.statusCode === 404) ? null : undefined;
-            return {
-                data,
-                fetchedAt: Date.now()
-            };
-        }
-        try {
-            const data = await asJson(response);
-            if (data) {
-                return {
-                    data,
-                    fetchedAt: Date.now()
-                };
-            }
-            this.logService.error("[DefaultAccount] Failed to fetch entitlements", "No data returned");
-        } catch (error) {
-            this.logService.error("[DefaultAccount] Failed to fetch entitlements", getErrorMessage(error));
-        }
-        return {
-            data: undefined,
-            fetchedAt: Date.now()
-        };
-    }
-    async getMcpRegistryProvider(sessions, accountPolicyData, options) {
-        if (!options?.forceRefresh && accountPolicyData?.mcpRegistryDataFetchedAt && !this.isDataStale(accountPolicyData.mcpRegistryDataFetchedAt)) {
-            this.logService.debug("[DefaultAccount] Using last fetched MCP registry data");
-            const data = accountPolicyData.policyData.mcpRegistryUrl && accountPolicyData.policyData.mcpAccess ? {
-                url: accountPolicyData.policyData.mcpRegistryUrl,
-                registry_access: accountPolicyData.policyData.mcpAccess
-            } : null;
-            return {
-                data,
-                fetchedAt: accountPolicyData.mcpRegistryDataFetchedAt
-            };
-        }
-        const data = await this.requestMcpRegistryProvider(sessions);
-        return !isUndefined(data) ? {
-            data,
-            fetchedAt: Date.now()
-        } : undefined;
-    }
-    async requestMcpRegistryProvider(sessions) {
-        const mcpRegistryDataUrl = this.getMcpRegistryDataUrl();
-        if (!mcpRegistryDataUrl) {
-            this.logService.debug("[DefaultAccount] No MCP registry data URL found");
-            return null;
-        }
-        this.logService.debug("[DefaultAccount] Fetching MCP registry data from:", mcpRegistryDataUrl);
-        const response = await this.request(
-            mcpRegistryDataUrl,
-            "GET",
-            undefined,
-            sessions,
-            CancellationToken.None,
-            "defaultAccount.mcpRegistryProvider"
-        );
-        if (!response) {
-            return undefined;
-        }
-        if (!isSuccess(response)) {
-            if (isClientError(response)) {
-                this.logService.debug(
-                    `[DefaultAccount] Received ${response.res.statusCode} for MCP registry data, treating as no registry available.`
-                );
-                return null;
-            }
-            this.logService.debug(
-                `[DefaultAccount] unexpected status code ${response.res.statusCode} while fetching MCP registry data`
-            );
-            return undefined;
-        }
-        try {
-            const data = await asJson(response);
-            if (data) {
-                this.logService.debug("Fetched MCP registry providers", data.mcp_registries);
-                return data.mcp_registries[0] ?? null;
-            }
-            this.logService.debug("No MCP registry providers content found in response");
-            return null;
-        } catch (error) {
-            this.logService.error("Failed to fetch MCP registry providers", getErrorMessage(error));
-            return undefined;
-        }
-    }
-    async getManagedSettings(
-        sessions,
-        accountPolicyData,
-        options,
-        authenticationProvider = this.getDefaultAccountAuthenticationProvider(),
-        managedSettingsSources,
-        refreshRequirement
-    ) {
-        const accountId = sessions[0].account.id;
-        const sources = managedSettingsSources ?? (await this.initializeManagedSettingsSources());
-        const requirement = refreshRequirement ?? resolveForceRemoteSettingsRefresh(
-            sources.nativeMdm,
-            this.getScopedServerManagedSettings(accountPolicyData, authenticationProvider, accountId),
-            sources.file
-        );
-        const cachedManagedSettings = accountPolicyData?.managedSettingsFetchedAt !== undefined && !this.isDataStale(accountPolicyData.managedSettingsFetchedAt) ? {
-            data: {
-                managedSettings: accountPolicyData.policyData.managedSettings
-            },
-            fetchedAt: accountPolicyData.managedSettingsFetchedAt
-        } : undefined;
-        const managedSettingsUrl = this.getManagedSettingsUrl();
-        if (!managedSettingsUrl) {
-            this.logService.debug(
-                "[DefaultAccount] No managed settings URL configured; skipping enterprise policy fetch"
-            );
-            this._managedSettingsFetchStatus = "no-url";
-            if (requirement.effective) {
-                this.setManagedSettingsFreshness({
-                    state: ManagedSettingsFreshnessState.Blocked,
-                    source: requirement.source,
-                    failure: ManagedSettingsFreshnessFailure.NoUrl
-                });
-            }
-            const retained = requirement.effective ? {
-                data: {
-                    managedSettings: accountPolicyData?.policyData.managedSettings
-                },
-                fetchedAt: accountPolicyData?.managedSettingsFetchedAt
-            } : cachedManagedSettings;
-            return {
-                data: retained?.data,
-                fetchedAt: retained?.fetchedAt,
-                scope: accountPolicyData?.managedSettingsScope,
-                compatibilityError: this._managedSettingsCompatibilityError
-            };
-        }
-        const scope = this.createManagedSettingsFreshnessScope(accountId, authenticationProvider.id, managedSettingsUrl);
-        const cachedScope = accountPolicyData?.managedSettingsScope;
-        const cacheScopeMatches = !cachedScope || this.getManagedSettingsScopeKey(cachedScope) === this.getManagedSettingsScopeKey(scope);
-        const scopedManagedSettings = cacheScopeMatches ? accountPolicyData?.policyData.managedSettings : undefined;
-        const scopedManagedSettingsFetchedAt = cacheScopeMatches ? accountPolicyData?.managedSettingsFetchedAt : undefined;
-        const scopedCachedManagedSettings = cacheScopeMatches ? cachedManagedSettings : undefined;
-        if (requirement.effective && !this.canRequestManagedSettings(options, scope)) {
-            this.logService.debug(
-                "[DefaultAccount] Skipping automatic managed settings retry after a prior failure"
-            );
-            const failedFreshness = this.failedManagedSettingsFreshness.get(this.getManagedSettingsScopeKey(scope));
-            if (failedFreshness) {
-                this.setManagedSettingsFreshness({
-                    ...failedFreshness,
-                    source: requirement.source
-                });
-            }
-            return {
-                data: {
-                    managedSettings: scopedManagedSettings
-                },
-                fetchedAt: scopedManagedSettingsFetchedAt,
-                scope,
-                compatibilityError: this._managedSettingsCompatibilityError
-            };
-        }
-        const freshnessSatisfied = requirement.effective && isManagedSettingsFreshnessSatisfiedFor(this._managedSettingsFreshness, scope);
-        if (!options?.forceRefresh && !options?.retryManagedSettings && scopedCachedManagedSettings && (!requirement.effective || freshnessSatisfied) && !this._managedSettingsCompatibilityError) {
-            this.logService.debug("[DefaultAccount] Using last fetched managed settings data");
-            return {
-                ...scopedCachedManagedSettings,
-                scope,
-                compatibilityError: this._managedSettingsCompatibilityError
-            };
-        }
-        const lastAttemptAt = Date.now();
-        if (requirement.effective) {
-            this.setManagedSettingsFreshness({
-                state: ManagedSettingsFreshnessState.Pending,
-                source: requirement.source,
-                scope,
-                lastAttemptAt
-            });
-        }
-        const sharedBackoffActive = Date.now() < this._rateLimitBackoffUntil;
-        const result = await this.requestManagedSettings(requirement.effective ? [sessions[0]] : sessions, managedSettingsUrl);
-        if (requirement.effective && !sharedBackoffActive) {
-            this.updateFailedManagedSettingsFreshness(scope, requirement.source, result, lastAttemptAt);
-        }
-        switch (result.kind) {
-        case "success":
-            {
-                const fetchedAt = Date.now();
-                this.resolveManagedSettingsFreshnessAfterSuccess(result.data.managedSettings, scope, lastAttemptAt, fetchedAt);
-                return {
-                    data: result.data,
-                    fetchedAt,
-                    scope,
-                    compatibilityError: null
-                };
-            }
-        case "noSettings":
-            {
-                const fetchedAt = Date.now();
-                this.resolveManagedSettingsFreshnessAfterSuccess(undefined, scope, lastAttemptAt, fetchedAt);
-                return {
-                    data: {
-                        managedSettings: undefined
-                    },
-                    fetchedAt,
-                    scope,
-                    compatibilityError: null
-                };
-            }
-        case "updateRequired":
-            if (requirement.effective) {
-                this.setManagedSettingsFreshness({
-                    state: ManagedSettingsFreshnessState.Blocked,
-                    source: requirement.source,
-                    scope,
-                    lastAttemptAt,
-                    failure: ManagedSettingsFreshnessFailure.UpdateRequired
-                });
-            }
-            return {
-                data: requirement.effective ? {
-                    managedSettings: scopedManagedSettings
-                } : {
-                    managedSettings: undefined
-                },
-                fetchedAt: requirement.effective ? scopedManagedSettingsFetchedAt : Date.now(),
-                scope,
-                compatibilityError: result.error
-            };
-        case "network":
-        case "rateLimited":
-        case "httpError":
-        case "malformed":
-            {
-                if (requirement.effective) {
-                    this.setManagedSettingsFreshness(
-                        this.toBlockedManagedSettingsFreshness(requirement.source, result, lastAttemptAt, scope)
-                    );
-                    return {
-                        data: {
-                            managedSettings: scopedManagedSettings
-                        },
-                        fetchedAt: scopedManagedSettingsFetchedAt,
-                        scope,
-                        compatibilityError: this._managedSettingsCompatibilityError
-                    };
-                }
-                const retained = this._managedSettingsCompatibilityError ? undefined : scopedCachedManagedSettings;
-                return {
-                    data: {
-                        managedSettings: retained?.data.managedSettings
-                    },
-                    fetchedAt: retained?.fetchedAt,
-                    scope,
-                    compatibilityError: this._managedSettingsCompatibilityError
-                };
-            }
-        }
-    }
-    createManagedSettingsFreshnessScope(accountId, authenticationProviderId, managedSettingsUrl) {
-        let endpointOrigin = managedSettingsUrl;
-        try {
-            endpointOrigin = ( new URL(managedSettingsUrl)).origin;
-        } catch {}
-        return {
-            accountId,
-            authenticationProviderId,
-            endpointOrigin
-        };
-    }
-    resolveManagedSettingsFreshnessAfterSuccess(server, scope, lastAttemptAt, satisfiedAt) {
-        const freshRequirement = resolveForceRemoteSettingsRefresh(
-            this.nativeManagedSettingsService.managedSettings,
-            server,
-            this.fileManagedSettingsService.managedSettings
-        );
-        this.setManagedSettingsFreshness(freshRequirement.effective ? {
-            state: ManagedSettingsFreshnessState.Satisfied,
-            source: freshRequirement.source,
-            scope,
-            lastAttemptAt,
-            satisfiedAt
-        } : MANAGED_SETTINGS_FRESHNESS_NOT_REQUIRED);
-    }
-    toBlockedManagedSettingsFreshness(source, result, lastAttemptAt, scope) {
-        switch (result.kind) {
-        case "network":
-            return {
-                state: ManagedSettingsFreshnessState.Blocked,
-                source,
-                scope,
-                lastAttemptAt,
-                failure: ManagedSettingsFreshnessFailure.Network
-            };
-        case "rateLimited":
-            return {
-                state: ManagedSettingsFreshnessState.Blocked,
-                source,
-                scope,
-                lastAttemptAt,
-                failure: ManagedSettingsFreshnessFailure.RateLimited
-            };
-        case "httpError":
-            return {
-                state: ManagedSettingsFreshnessState.Blocked,
-                source,
-                scope,
-                lastAttemptAt,
-                failure: ManagedSettingsFreshnessFailure.HttpError,
-                httpStatus: result.status
-            };
-        case "malformed":
-            return {
-                state: ManagedSettingsFreshnessState.Blocked,
-                source,
-                scope,
-                lastAttemptAt,
-                failure: ManagedSettingsFreshnessFailure.Malformed
-            };
-        }
-    }
-    async requestManagedSettings(sessions, managedSettingsUrl) {
-        const requestUrl = appendManagedSettingsClientIdentity(managedSettingsUrl, this.productService);
-        this.logService.debug("[DefaultAccount] Fetching managed settings from:", requestUrl);
-        const rateLimitBackoffActive = Date.now() < this._rateLimitBackoffUntil;
-        const response = await this.request(
-            requestUrl,
-            "GET",
-            undefined,
-            sessions,
-            CancellationToken.None,
-            "defaultAccount.managedSettings",
-            {
-                requestTimeoutMs: MANAGED_SETTINGS_REQUEST_TIMEOUT_MS,
-                retryNotFound: false
-            }
-        );
-        if (!response) {
-            this.logService.debug(
-                "[DefaultAccount] Managed settings fetch returned no response (network error, all selected sessions rejected, or active rate-limit backoff); falling back to local-only policy"
-            );
-            this.reportManagedSettingsOutcome("no-response", rateLimitBackoffActive);
-            return rateLimitBackoffActive ? {
-                kind: "rateLimited"
-            } : {
-                kind: "network"
-            };
-        }
-        const status = response.res.statusCode ?? 0;
-        if (status === 404) {
-            this.reportManagedSettingsOutcome(status, rateLimitBackoffActive);
-            return {
-                kind: "noSettings"
-            };
-        }
-        if (status === 466) {
-            const error = await this.readManagedSettingsCompatibilityError(response);
-            this.setManagedSettingsCompatibilityError(error);
-            this.reportManagedSettingsOutcome(status, rateLimitBackoffActive);
-            return {
-                kind: "updateRequired",
-                error
-            };
-        }
-        if (this.isRateLimited(response)) {
-            this.reportManagedSettingsOutcome(status, rateLimitBackoffActive);
-            return {
-                kind: "rateLimited"
-            };
-        }
-        if (!isSuccess(response)) {
-            this.logService.warn(
-                `[DefaultAccount] Managed settings fetch returned non-success status ${status}; falling back to local-only policy`
-            );
-            this.reportManagedSettingsOutcome(status, rateLimitBackoffActive);
-            return {
-                kind: "httpError",
-                status
-            };
-        }
-        try {
-            const data = await asJson(response);
-            this.logService.trace(
-                "[DefaultAccount] Managed settings raw response:",
-                JSON.stringify(data ?? null)
-            );
-            this._managedSettingsRawResponse = data ?? null;
-            const adapted = adaptManagedSettings(data ?? {}, msg => this.logService.warn(msg));
-            const managedSettingsCount = adapted.managedSettings ? ( Object.keys(adapted.managedSettings)).length : 0;
-            if (managedSettingsCount === 0 && adapted.managedSettingsActive !== true) {
-                this.logService.debug(
-                    "[DefaultAccount] Managed settings fetched (empty response — no enterprise policy file present)"
-                );
-            } else {
-                this.logService.info("[DefaultAccount] Managed settings applied");
-                this.logService.trace("[DefaultAccount] Managed settings payload:", JSON.stringify(adapted));
-            }
-            this.reportManagedSettingsOutcome("ok", rateLimitBackoffActive);
-            return {
-                kind: "success",
-                data: adapted
-            };
-        } catch (error) {
-            this.logService.error(
-                "[DefaultAccount] Failed to parse managed settings response",
-                getErrorMessage(error)
-            );
-            this.reportManagedSettingsOutcome("parse-error", rateLimitBackoffActive);
-            return {
-                kind: "malformed"
-            };
-        }
-    }
-    canRequestManagedSettings(options, scope) {
-        return options?.retryManagedSettings === true || scope === undefined || !( this.failedManagedSettingsFreshness.has(this.getManagedSettingsScopeKey(scope)));
-    }
-    updateFailedManagedSettingsFreshness(scope, source, result, lastAttemptAt) {
-        const scopeKey = this.getManagedSettingsScopeKey(scope);
-        switch (result.kind) {
-        case "success":
-        case "noSettings":
-            this.failedManagedSettingsFreshness.delete(scopeKey);
-            break;
-        case "updateRequired":
-            {
-                this.failedManagedSettingsFreshness.set(scopeKey, {
-                    state: ManagedSettingsFreshnessState.Blocked,
-                    source,
-                    scope,
-                    lastAttemptAt,
-                    failure: ManagedSettingsFreshnessFailure.UpdateRequired
-                });
-                break;
-            }
-        case "network":
-        case "rateLimited":
-        case "httpError":
-        case "malformed":
-            {
-                this.failedManagedSettingsFreshness.set(
-                    scopeKey,
-                    this.toBlockedManagedSettingsFreshness(source, result, lastAttemptAt, scope)
-                );
-                break;
-            }
-        }
-    }
-    getManagedSettingsScopeKey(scope) {
-        return `${scope.authenticationProviderId}\n${scope.accountId}\n${scope.endpointOrigin}`;
-    }
-    async readManagedSettingsCompatibilityError(response) {
-        try {
-            const text = await asText(response);
-            const body = text ? JSON.parse(text) : undefined;
-            const parsed = parseManagedSettingsCompatibilityError(body);
-            if (parsed) {
-                return parsed;
-            }
-            this.logService.error(
-                "[DefaultAccount] Managed settings compatibility response did not contain the expected error code"
-            );
-        } catch (error) {
-            this.logService.error(
-                "[DefaultAccount] Failed to parse managed settings compatibility response",
-                getErrorMessage(error)
-            );
-        }
-        return {
-            errorCode: MANAGED_SETTINGS_UPDATE_REQUIRED_ERROR_CODE
-        };
-    }
-    reportManagedSettingsOutcome(status, rateLimitBackoffActive) {
-        this._managedSettingsFetchStatus = status;
-        this.telemetryService.publicLog2("defaultaccount:managedSettings:fetch", {
-            outcome: typeof status === "number" ? `status:${status}` : status,
-            rateLimitBackoffActive
-        });
-    }
-    isRateLimited(response) {
-        const status = response.res.statusCode;
-        if (status === 429) {
-            return true;
-        }
-        if (status === 403 && readHeader(response.res.headers, "x-ratelimit-remaining") === "0") {
-            return true;
-        }
-        if (!isSuccess(response) && readHeader(response.res.headers, "retry-after") !== undefined) {
-            return true;
-        }
-        return false;
-    }
-    async request(url, type, body, sessions, token, callSite, options) {
-        if (Date.now() < this._rateLimitBackoffUntil) {
-            const remainingSec = Math.ceil((this._rateLimitBackoffUntil - Date.now()) / 1000);
-            this.logService.debug(
-                `[DefaultAccount] Skipping request to ${url} — rate-limit backoff active for ${remainingSec}s more`
-            );
-            return undefined;
-        }
-        let lastResponse;
-        for (const session of sessions) {
-            if (token.isCancellationRequested) {
-                return lastResponse;
-            }
-            try {
-                const response = await this.requestService.request({
-                    type,
-                    url,
-                    data: type === "POST" ? JSON.stringify(body) : undefined,
-                    disableCache: true,
-                    timeout: options?.requestTimeoutMs,
-                    headers: {
-                        "Authorization": `Bearer ${session.accessToken}`
-                    },
-                    callSite
-                }, token);
-                const status = response.res.statusCode;
-                if (this.isRateLimited(response)) {
-                    const retryAfterSec = retryAfterFromHeaders(response.res.headers) ?? 60;
-                    this._rateLimitBackoffUntil = Date.now() + retryAfterSec * 1000;
-                    this.logService.warn(
-                        `[DefaultAccount] Rate limited by ${url} (status ${status}); backing off for ${retryAfterSec}s`
-                    );
-                    return response;
-                }
-                if (status === 401 || (status === 404 && options?.retryNotFound !== false)) {
-                    this.logService.debug(
-                        `[DefaultAccount] Received ${status} for URL ${url} with session ${session.id}, likely due to expired/revoked token or insufficient permissions.`,
-                        "Trying next session if available."
-                    );
-                    lastResponse = response;
-                    continue;
-                }
-                return response;
-            } catch (error) {
-                if (!token.isCancellationRequested) {
-                    this.logService.error(`[DefaultAccount] request: error ${error}`, url);
-                }
-            }
-        }
-        if (!lastResponse) {
-            this.logService.trace("[DefaultAccount]: No response received for request", url);
-            return undefined;
-        }
-        return lastResponse;
-    }
-    isDataStale(fetchedAt) {
-        return (Date.now() - fetchedAt) >= ACCOUNT_DATA_POLL_INTERVAL_MS;
-    }
-    getEntitlementUrl() {
-        if (this.getDefaultAccountAuthenticationProvider().enterprise) {
-            try {
-                const enterpriseUrl = this.getEnterpriseUrl();
-                if (!enterpriseUrl) {
-                    return undefined;
-                }
-                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ":" + enterpriseUrl.port : ""}/copilot_internal/user`;
-            } catch (error) {
-                this.logService.error(error);
-            }
-        }
-        return this.defaultAccountConfig.entitlementUrl;
-    }
-    getTokenEntitlementUrl() {
-        if (this.getDefaultAccountAuthenticationProvider().enterprise) {
-            try {
-                const enterpriseUrl = this.getEnterpriseUrl();
-                if (!enterpriseUrl) {
-                    return undefined;
-                }
-                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ":" + enterpriseUrl.port : ""}/copilot_internal/v2/token`;
-            } catch (error) {
-                this.logService.error(error);
-            }
-        }
-        return this.defaultAccountConfig.tokenEntitlementUrl;
-    }
-    getMcpRegistryDataUrl() {
-        if (this.getDefaultAccountAuthenticationProvider().enterprise) {
-            try {
-                const enterpriseUrl = this.getEnterpriseUrl();
-                if (!enterpriseUrl) {
-                    return undefined;
-                }
-                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ":" + enterpriseUrl.port : ""}/copilot/mcp_registry`;
-            } catch (error) {
-                this.logService.error(error);
-            }
-        }
-        return this.defaultAccountConfig.mcpRegistryDataUrl;
-    }
-    getManagedSettingsUrl() {
-        if (this.getDefaultAccountAuthenticationProvider().enterprise) {
-            try {
-                const enterpriseUrl = this.getEnterpriseUrl();
-                if (!enterpriseUrl) {
-                    return undefined;
-                }
-                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ":" + enterpriseUrl.port : ""}/copilot_internal/managed_settings`;
-            } catch (error) {
-                this.logService.error(error);
-            }
-        }
-        return this.defaultAccountConfig.managedSettingsUrl;
-    }
-    getDefaultAccountAuthenticationProvider() {
-        if (this.configurationService.getValue(this.defaultAccountConfig.authenticationProvider.enterpriseProviderConfig) === this.defaultAccountConfig.authenticationProvider.enterprise.id) {
-            return {
-                ...this.defaultAccountConfig.authenticationProvider.enterprise,
-                enterprise: true
-            };
-        }
-        return {
-            ...this.defaultAccountConfig.authenticationProvider.default,
-            enterprise: false
-        };
-    }
-    resolveGitHubUrl(path) {
-        if (this.getDefaultAccountAuthenticationProvider().enterprise) {
-            try {
-                const enterpriseUrl = this.getEnterpriseUrl();
-                if (enterpriseUrl) {
-                    return `${enterpriseUrl.protocol}//${enterpriseUrl.host}/${path}`;
-                }
-            } catch {}
-        }
-        return `https://github.com/${path}`;
-    }
-    getEnterpriseUrl() {
-        const value = this.configurationService.getValue(
-            this.defaultAccountConfig.authenticationProvider.enterpriseProviderUriSetting
-        );
-        if (!isString(value)) {
-            return undefined;
-        }
-        return ( new URL(value));
-    }
-    async signIn(options) {
-        const authProvider = this.getDefaultAccountAuthenticationProvider();
-        if (!authProvider) {
-            throw ( new Error("No default account provider configured"));
-        }
-        const {
-            additionalScopes,
-            ...sessionOptions
-        } = options ?? {};
-        const defaultAccountScopes = this.defaultAccountConfig.authenticationProvider.scopes[0];
-        const scopes = additionalScopes ? distinct([...defaultAccountScopes, ...additionalScopes]) : defaultAccountScopes;
-        const session = await this.authenticationService.createSession(authProvider.id, scopes, sessionOptions);
-        for (const preferredExtension of this.defaultAccountConfig.preferredExtensions) {
-            this.authenticationExtensionsService.updateAccountPreference(preferredExtension, authProvider.id, session.account);
-        }
-        await this.updateDefaultAccount();
-        return this.defaultAccount;
-    }
-    async signOut() {
-        if (!this.defaultAccount) {
-            return;
-        }
-        await this.commandService.executeCommand("_signOutOfAccount", {
-            providerId: this.defaultAccount.authenticationProvider.id,
-            accountLabel: this.defaultAccount.accountName
-        });
-    }
-};
-DefaultAccountProvider = ( __decorate([( __param(1, IConfigurationService)), ( __param(2, IAuthenticationService)), ( __param(3, IAuthenticationExtensionsService)), ( __param(4, ITelemetryService)), ( __param(5, IExtensionService)), ( __param(6, IRequestService)), ( __param(7, ILogService)), ( __param(8, IWorkbenchEnvironmentService)), ( __param(9, IProductService)), ( __param(10, IContextKeyService)), ( __param(11, IStorageService)), ( __param(12, IHostService)), ( __param(13, ICommandService)), ( __param(14, INativeManagedSettingsService)), ( __param(15, IFileManagedSettingsService))], DefaultAccountProvider));
-let DefaultAccountProviderContribution = class DefaultAccountProviderContribution extends Disposable {
-    static {
-        this.ID = "workbench.contributions.defaultAccountProvider";
-    }
-    constructor(productService, instantiationService, defaultAccountService) {
-        super();
-        if (productService.defaultChatAgent) {
-            const defaultAccountProvider = this._register(instantiationService.createInstance(
-                DefaultAccountProvider,
-                toDefaultAccountConfig(productService.defaultChatAgent)
-            ));
-            defaultAccountService.setDefaultAccountProvider(defaultAccountProvider);
-        }
-    }
-};
-DefaultAccountProviderContribution = ( __decorate([( __param(0, IProductService)), ( __param(1, IInstantiationService)), ( __param(2, IDefaultAccountService))], DefaultAccountProviderContribution));
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: DEFAULT_ACCOUNT_SIGN_IN_COMMAND,
-            title: ( localize2(18953, "Sign In"))
-        });
-    }
-    async run(accessor) {
-        const defaultAccountService = accessor.get(IDefaultAccountService);
-        await defaultAccountService.signIn();
-    }
-});
-registerWorkbenchContribution2(
-    DefaultAccountProviderContribution.ID,
-    DefaultAccountProviderContribution,
-    WorkbenchPhase.BlockStartup
-);
-
-export { CONTEXT_DEFAULT_ACCOUNT_STATE, DEFAULT_ACCOUNT_SIGN_IN_COMMAND, DefaultAccountProvider, DefaultAccountStatus };