@codingame/monaco-vscode-api 26.2.2 → 28.0.0

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

@@ -1,31 +1,34 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { distinct } from '../../../../base/common/arrays.js';
+import { ThrottledDelayer, RunOnceScheduler, timeout } from '../../../../base/common/async.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { getErrorMessage } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { IProductService } from '../../../../platform/product/common/productService.service.js';
-import { IAuthenticationService, IAuthenticationExtensionsService } from '../../authentication/common/authentication.service.js';
-import { asJson } from '../../../../platform/request/common/request.js';
-import { IRequestService } from '../../../../platform/request/common/request.service.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
-import { IExtensionService } from '../../extensions/common/extensions.service.js';
-import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { equals } from '../../../../base/common/objects.js';
+import { isWeb } from '../../../../base/common/platform.js';
+import { isUndefined, isString } from '../../../../base/common/types.js';
+import { localize2 } from '../../../../nls.js';
+import { registerAction2, Action2 } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
-import { registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
-import { ThrottledDelayer, RunOnceScheduler, timeout } from '../../../../base/common/async.js';
-import { IHostService } from '../../host/browser/host.service.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
-import { getErrorMessage } from '../../../../base/common/errors.js';
-import { isUndefined, isString } from '../../../../base/common/types.js';
+import { IDefaultAccountService } from '../../../../platform/defaultAccount/common/defaultAccount.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { asJson, isSuccess, isClientError } from '../../../../platform/request/common/request.js';
+import { IRequestService } from '../../../../platform/request/common/request.service.js';
 import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
-import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
-import { isWeb } from '../../../../base/common/platform.js';
-import { IDefaultAccountService } from '../../../../platform/defaultAccount/common/defaultAccount.service.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
-import { distinct } from '../../../../base/common/arrays.js';
-import { equals } from '../../../../base/common/objects.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
+import { IAuthenticationService, IAuthenticationExtensionsService } from '../../authentication/common/authentication.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { IExtensionService } from '../../extensions/common/extensions.service.js';
+import { IHostService } from '../../host/browser/host.service.js';
 
 const DEFAULT_ACCOUNT_SIGN_IN_COMMAND = "workbench.actions.accounts.signIn";
 var DefaultAccountStatus;
@@ -65,6 +68,9 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
     get policyData() {
         return this._policyData?.policyData ?? null;
     }
+    get copilotTokenInfo() {
+        return this._copilotTokenInfo;
+    }
     constructor(
         defaultAccountConfig,
         configurationService,
@@ -77,7 +83,8 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         environmentService,
         contextKeyService,
         storageService,
-        hostService
+        hostService,
+        commandService
     ) {
         super();
         this.defaultAccountConfig = defaultAccountConfig;
@@ -91,17 +98,23 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         this.environmentService = environmentService;
         this.storageService = storageService;
         this.hostService = hostService;
+        this.commandService = commandService;
         this._defaultAccount = null;
         this._policyData = null;
+        this._copilotTokenInfo = null;
         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.initialized = false;
         this.updateThrottler = this._register(( new ThrottledDelayer(100)));
-        this.accountDataPollScheduler = this._register(( new RunOnceScheduler(() => this.refetchPolicyData(), ACCOUNT_DATA_POLL_INTERVAL_MS)));
+        this.accountDataPollScheduler = this._register(( new RunOnceScheduler(() => this.refetchDefaultAccount(), ACCOUNT_DATA_POLL_INTERVAL_MS)));
         this.accountStatusContext = CONTEXT_DEFAULT_ACCOUNT_STATE.bindTo(contextKeyService);
-        this._policyData = this.getCachedPolicyData();
+        const cachedAccountData = this.getCachedAccountData();
+        this._policyData = cachedAccountData?.accountPolicyData ?? null;
+        this._copilotTokenInfo = cachedAccountData?.copilotTokenInfo ?? null;
         this.initPromise = this.init().finally(() => {
             this.telemetryService.publicLog2("defaultaccount:status", {
                 status: this.defaultAccount ? "available" : "unavailable",
@@ -110,21 +123,48 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             this.initialized = true;
         });
     }
-    getCachedPolicyData() {
+    getCachedAccountData() {
         const cached = this.storageService.get(CACHED_POLICY_DATA_KEY, StorageScope.APPLICATION);
         if (cached) {
             try {
+                const parsed = JSON.parse(cached);
                 const {
                     accountId,
-                    policyData
-                } = JSON.parse(cached);
+                    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 {
-                        accountId,
-                        policyData,
-                        isTokenEntitlementsDataFetched: false,
-                        isMcpRegistryDataFetched: false
+                        accountPolicyData,
+                        copilotTokenInfo: wrappedCopilotTokenInfo
                     };
                 }
             } catch (error) {
@@ -151,7 +191,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
         }
         this.logService.debug("[DefaultAccount] Starting initialization");
-        await this.doUpdateDefaultAccount(false, false);
+        await this.doUpdateDefaultAccount();
         this.logService.debug("[DefaultAccount] Initialization complete");
         this._register(this.onDidChangeDefaultAccount(account => {
             this.telemetryService.publicLog2("defaultaccount:status", {
@@ -206,39 +246,40 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             this.updateDefaultAccount();
         }));
         this._register(this.hostService.onDidChangeFocus(focused => {
-            if (focused && this._defaultAccount && this._policyData && (!this._policyData.isMcpRegistryDataFetched || !this._policyData.isTokenEntitlementsDataFetched)) {
-                this.accountDataPollScheduler.cancel();
-                this.logService.debug("[DefaultAccount] Window focused, updating default account");
-                this.refresh(true);
+            if (focused) {
+                this.refetchDefaultAccount(true);
             }
         }));
     }
-    async refresh(donotFetchEntitlements = false) {
+    async refresh() {
         if (!this.initialized) {
             await this.initPromise;
             return this.defaultAccount;
         }
         this.logService.debug("[DefaultAccount] Refreshing default account");
-        await this.updateDefaultAccount(false, donotFetchEntitlements);
+        await this.updateDefaultAccount();
         return this.defaultAccount;
     }
-    async refetchPolicyData() {
-        if (!this.hostService.hasFocus) {
+    async refetchDefaultAccount(useExistingEntitlements) {
+        if (this.accountDataPollScheduler.isScheduled()) {
+            this.accountDataPollScheduler.cancel();
+        }
+        if (!this.hostService.hasFocus || !this._defaultAccount) {
             this.scheduleAccountDataPoll();
             this.logService.debug(
-                "[DefaultAccount] Skipping refetching policy data because window is not focused"
+                "[DefaultAccount] Skipping refetching default account. Host is not focused or default account is not set"
             );
             return;
         }
-        this.logService.debug("[DefaultAccount] Refetching policy data for current default account");
-        await this.updateDefaultAccount(true);
+        this.logService.debug("[DefaultAccount] Refetching default account");
+        await this.updateDefaultAccount(useExistingEntitlements);
     }
-    async updateDefaultAccount(donotUseCache = false, donotFetchEntitlements = false) {
-        await this.updateThrottler.trigger(() => this.doUpdateDefaultAccount(donotUseCache, donotFetchEntitlements));
+    async updateDefaultAccount(useExistingEntitlements) {
+        await this.updateThrottler.trigger(() => this.doUpdateDefaultAccount(useExistingEntitlements));
     }
-    async doUpdateDefaultAccount(donotUseCache, donotFetchEntitlements) {
+    async doUpdateDefaultAccount(useExistingEntitlements = false) {
         try {
-            const defaultAccount = await this.fetchDefaultAccount(donotUseCache, donotFetchEntitlements);
+            const defaultAccount = await this.fetchDefaultAccount(useExistingEntitlements);
             this.setDefaultAccount(defaultAccount);
             this.scheduleAccountDataPoll();
         } catch (error) {
@@ -248,7 +289,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
         }
     }
-    async fetchDefaultAccount(donotUseCache, donotFetchEntitlements) {
+    async fetchDefaultAccount(useExistingEntitlements) {
         const defaultAccountProvider = this.getDefaultAccountAuthenticationProvider();
         this.logService.debug("[DefaultAccount] Default account provider ID:", defaultAccountProvider.id);
         const declaredProvider = this.authenticationService.declaredProviders.find(provider => provider.id === defaultAccountProvider.id);
@@ -259,7 +300,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
             return null;
         }
-        return await this.getDefaultAccountForAuthenticationProvider(defaultAccountProvider, donotUseCache, donotFetchEntitlements);
+        return await this.getDefaultAccountForAuthenticationProvider(defaultAccountProvider, useExistingEntitlements);
     }
     setDefaultAccount(account) {
         if (equals(this._defaultAccount, account)) {
@@ -268,6 +309,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         this.logService.trace("[DefaultAccount] Updating default account:", account);
         if (account) {
             this._defaultAccount = account;
+            this.setCopilotTokenInfo(account.copilotTokenInfo);
             this.setPolicyData(account.policyData);
             this._onDidChangeDefaultAccount.fire(this._defaultAccount.defaultAccount);
             this.accountStatusContext.set(DefaultAccountStatus.Available);
@@ -275,6 +317,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         } else {
             this._defaultAccount = null;
             this.setPolicyData(null);
+            this.setCopilotTokenInfo(null);
             this._onDidChangeDefaultAccount.fire(null);
             this.accountDataPollScheduler.cancel();
             this.accountStatusContext.set(DefaultAccountStatus.Unavailable);
@@ -289,15 +332,26 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         this.cachePolicyData(accountPolicyData);
         this._onDidChangePolicyData.fire(this._policyData?.policyData ?? null);
     }
+    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(accountPolicyData),
+                JSON.stringify(cachedAccountData),
                 StorageScope.APPLICATION,
                 StorageTarget.MACHINE
             );
@@ -325,7 +379,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         );
         return result;
     }
-    async getDefaultAccountForAuthenticationProvider(authenticationProvider, donotUseCache, donotFetchEntitlements) {
+    async getDefaultAccountForAuthenticationProvider(authenticationProvider, useExistingEntitlements) {
         try {
             this.logService.debug(
                 "[DefaultAccount] Getting Default Account from authenticated sessions for provider:",
@@ -342,7 +396,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                 );
                 return null;
             }
-            return this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, donotUseCache, donotFetchEntitlements);
+            return this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, useExistingEntitlements);
         } catch (error) {
             this.logService.error(
                 "[DefaultAccount] Failed to get default account for provider:",
@@ -352,32 +406,32 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             return null;
         }
     }
-    async getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, donotUseCache, donotFetchEntitlements) {
+    async getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, useExistingEntitlements) {
         try {
             const accountId = sessions[0].account.id;
+            const existingEntitlementsData = this._defaultAccount?.accountId === accountId ? this._defaultAccount?.defaultAccount.entitlementsData : undefined;
             const accountPolicyData = this._policyData?.accountId === accountId ? this._policyData : undefined;
-            const [entitlementsData, tokenEntitlementsData] = await Promise.all([
-                donotFetchEntitlements && accountPolicyData && this._defaultAccount ? this._defaultAccount.defaultAccount.entitlementsData : this.getEntitlements(sessions),
-                this.getTokenEntitlements(sessions, donotUseCache ? undefined : accountPolicyData)
+            const [entitlementsData, tokenEntitlementsResult] = await Promise.all([
+                useExistingEntitlements && existingEntitlementsData ? existingEntitlementsData : this.getEntitlements(sessions),
+                this.getTokenEntitlements(sessions, accountPolicyData)
             ]);
-            let isTokenEntitlementsDataFetched = false;
-            let isMcpRegistryDataFetched = false;
+            let tokenEntitlementsFetchedAt;
+            let mcpRegistryDataFetchedAt;
             let policyData = accountPolicyData?.policyData ? {
                 ...accountPolicyData.policyData
             } : undefined;
-            if (tokenEntitlementsData) {
-                isTokenEntitlementsDataFetched = true;
+            if (tokenEntitlementsResult) {
+                tokenEntitlementsFetchedAt = tokenEntitlementsResult.fetchedAt;
+                const tokenEntitlementsData = tokenEntitlementsResult.data;
                 policyData = policyData ?? {};
-                policyData.chat_agent_enabled = tokenEntitlementsData.chat_agent_enabled;
-                policyData.chat_preview_features_enabled = tokenEntitlementsData.chat_preview_features_enabled;
-                policyData.mcp = tokenEntitlementsData.mcp;
+                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 mcpRegistryProvider = await this.getMcpRegistryProvider(sessions, donotUseCache ? undefined : accountPolicyData);
-                    if (!isUndefined(mcpRegistryProvider)) {
-                        isMcpRegistryDataFetched = true;
-                        policyData.mcpRegistryUrl = mcpRegistryProvider?.url;
-                        policyData.mcpAccess = mcpRegistryProvider?.registry_access;
-                    }
+                    const mcpRegistryResult = await this.getMcpRegistryProvider(sessions, accountPolicyData);
+                    mcpRegistryDataFetchedAt = mcpRegistryResult?.fetchedAt;
+                    policyData.mcpRegistryUrl = mcpRegistryResult?.data?.url;
+                    policyData.mcpAccess = mcpRegistryResult?.data?.registry_access;
                 } else {
                     policyData.mcpRegistryUrl = undefined;
                     policyData.mcpAccess = undefined;
@@ -385,6 +439,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             }
             const defaultAccount = {
                 authenticationProvider,
+                accountName: sessions[0].account.label,
                 sessionId: sessions[0].id,
                 enterprise: authenticationProvider.enterprise || sessions[0].account.label.includes("_"),
                 entitlementsData
@@ -395,12 +450,14 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
             return {
                 defaultAccount,
+                accountId,
                 policyData: policyData ? {
                     accountId,
                     policyData,
-                    isTokenEntitlementsDataFetched,
-                    isMcpRegistryDataFetched
-                } : null
+                    tokenEntitlementsFetchedAt,
+                    mcpRegistryDataFetchedAt
+                } : null,
+                copilotTokenInfo: tokenEntitlementsResult?.data.copilotTokenInfo ?? null
             };
         } catch (error) {
             this.logService.error(
@@ -461,11 +518,21 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         return expectedScopes.every(scope => scopes.includes(scope));
     }
     async getTokenEntitlements(sessions, accountPolicyData) {
-        if (accountPolicyData?.isTokenEntitlementsDataFetched) {
+        if (accountPolicyData?.tokenEntitlementsFetchedAt && !this.isDataStale(accountPolicyData.tokenEntitlementsFetchedAt)) {
             this.logService.debug("[DefaultAccount] Using last fetched token entitlements data");
-            return accountPolicyData.policyData;
+            return {
+                data: {
+                    policyData: accountPolicyData.policyData,
+                    copilotTokenInfo: this._copilotTokenInfo ?? {}
+                },
+                fetchedAt: accountPolicyData.tokenEntitlementsFetchedAt
+            };
         }
-        return await this.requestTokenEntitlements(sessions);
+        const data = await this.requestTokenEntitlements(sessions);
+        return data ? {
+            data,
+            fetchedAt: Date.now()
+        } : undefined;
     }
     async requestTokenEntitlements(sessions) {
         const tokenEntitlementsUrl = this.getTokenEntitlementUrl();
@@ -489,9 +556,15 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             if (chatData) {
                 const tokenMap = this.extractFromToken(chatData.token);
                 return {
-                    chat_preview_features_enabled: tokenMap.get("editor_preview_features") !== "0",
-                    chat_agent_enabled: tokenMap.get("agent_mode") !== "0",
-                    mcp: tokenMap.get("mcp") !== "0"
+                    policyData: {
+                        chat_preview_features_enabled: tokenMap.get("editor_preview_features") !== "0",
+                        chat_agent_enabled: tokenMap.get("agent_mode") !== "0",
+                        mcp: tokenMap.get("mcp") !== "0"
+                    },
+                    copilotTokenInfo: {
+                        sn: tokenMap.get("sn"),
+                        fcv1: tokenMap.get("fcv1")
+                    }
                 };
             }
             this.logService.error("Failed to fetch token entitlements", "No data returned");
@@ -532,14 +605,22 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         return undefined;
     }
     async getMcpRegistryProvider(sessions, accountPolicyData) {
-        if (accountPolicyData?.isMcpRegistryDataFetched) {
+        if (accountPolicyData?.mcpRegistryDataFetchedAt && !this.isDataStale(accountPolicyData.mcpRegistryDataFetchedAt)) {
             this.logService.debug("[DefaultAccount] Using last fetched MCP registry data");
-            return accountPolicyData.policyData.mcpRegistryUrl && accountPolicyData.policyData.mcpAccess ? {
+            const data = accountPolicyData.policyData.mcpRegistryUrl && accountPolicyData.policyData.mcpAccess ? {
                 url: accountPolicyData.policyData.mcpRegistryUrl,
                 registry_access: accountPolicyData.policyData.mcpAccess
             } : null;
+            return {
+                data,
+                fetchedAt: accountPolicyData.mcpRegistryDataFetchedAt
+            };
         }
-        return await this.requestMcpRegistryProvider(sessions);
+        const data = await this.requestMcpRegistryProvider(sessions);
+        return !isUndefined(data) ? {
+            data,
+            fetchedAt: Date.now()
+        } : undefined;
     }
     async requestMcpRegistryProvider(sessions) {
         const mcpRegistryDataUrl = this.getMcpRegistryDataUrl();
@@ -552,22 +633,10 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         if (!response) {
             return undefined;
         }
-        if (response.res.statusCode && response.res.statusCode !== 200) {
-            if (response.res.statusCode === 401) {
-                this.logService.debug(
-                    "[DefaultAccount] Unauthorized (401) when fetching MCP registry data, treating as no registry available"
-                );
-                return null;
-            }
-            if (response.res.statusCode === 404) {
-                this.logService.debug(
-                    "[DefaultAccount] MCP registry endpoint not found (404), treating as no registry available"
-                );
-                return null;
-            }
-            if (response.res.statusCode === 429) {
+        if (!isSuccess(response)) {
+            if (isClientError(response)) {
                 this.logService.debug(
-                    `[DefaultAccount] Received 429 Too Many Requests for MCP registry data, treating as no registry available and not retrying immediately.`
+                    `[DefaultAccount] Received ${response.res.statusCode} for MCP registry data, treating as no registry available.`
                 );
                 return null;
             }
@@ -606,11 +675,11 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                     }
                 }, token);
                 const status = response.res.statusCode;
-                if (status && status !== 200) {
-                    if (status === 429) {
-                        this.logService.warn(`[DefaultAccount] Received 429 Too Many Requests for ${url}.`);
-                        return response;
-                    }
+                if (status === 401 || status === 404) {
+                    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;
                 }
@@ -627,6 +696,9 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         }
         return lastResponse;
     }
+    isDataStale(fetchedAt) {
+        return (Date.now() - fetchedAt) >= ACCOUNT_DATA_POLL_INTERVAL_MS;
+    }
     getEntitlementUrl() {
         if (this.getDefaultAccountAuthenticationProvider().enterprise) {
             try {
@@ -708,8 +780,17 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         await this.updateDefaultAccount();
         return this.defaultAccount;
     }
+    async signOut() {
+        if (!this.defaultAccount) {
+            return;
+        }
+        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, IContextKeyService)), ( __param(10, IStorageService)), ( __param(11, IHostService))], DefaultAccountProvider));
+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, IContextKeyService)), ( __param(10, IStorageService)), ( __param(11, IHostService)), ( __param(12, ICommandService))], DefaultAccountProvider));
 let DefaultAccountProviderContribution = class DefaultAccountProviderContribution extends Disposable {
     static {
         this.ID = "workbench.contributions.defaultAccountProvider";
@@ -726,6 +807,18 @@ let DefaultAccountProviderContribution = class DefaultAccountProviderContributio
     }
 };
 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(15280, "Sign In"))
+        });
+    }
+    async run(accessor) {
+        const defaultAccountService = accessor.get(IDefaultAccountService);
+        await defaultAccountService.signIn();
+    }
+});
 registerWorkbenchContribution2(
     DefaultAccountProviderContribution.ID,
     DefaultAccountProviderContribution,

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.d.ts

@@ -3,7 +3,7 @@ import { ITelemetryService } from "../../../../platform/telemetry/common/telemet
 import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
 import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
 import { IProductService } from "../../../../platform/product/common/productService.service.js";
-import { IAssignmentService } from "../../../../platform/assignment/common/assignment.js";
+import { IAssignmentService } from "@codingame/monaco-vscode-update-service-override/vscode/vs/platform/assignment/common/assignment";
 import { IWorkbenchEnvironmentService } from "../../environment/common/environmentService.service.js";
 import { Disposable } from "../../../../base/common/lifecycle.js";
 import { Event } from "../../../../base/common/event.js";

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.service.d.ts

@@ -1,4 +1,4 @@
-import { IAssignmentService } from "../../../../platform/assignment/common/assignment.js";
+import { IAssignmentService } from "@codingame/monaco-vscode-update-service-override/vscode/vs/platform/assignment/common/assignment";
 import { IAssignmentFilter } from "./assignmentService.js";
 export declare const IWorkbenchAssignmentService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkbenchAssignmentService>;
 export interface IWorkbenchAssignmentService extends IAssignmentService {

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -42,23 +42,23 @@ const authenticationDefinitionSchema = {
     properties: {
         id: {
             type: "string",
-            description: ( localize(14307, "The id of the authentication provider."))
+            description: ( localize(15433, "The id of the authentication provider."))
         },
         label: {
             type: "string",
-            description: ( localize(14308, "The human readable name of the authentication provider."))
+            description: ( localize(15434, "The human readable name of the authentication provider."))
         },
         authorizationServerGlobs: {
             type: "array",
             items: {
                 type: "string",
                 description: ( localize(
-                    14309,
+                    15435,
                     "A list of globs that match the authorization servers that this provider supports."
                 ))
             },
             description: ( localize(
-                14310,
+                15436,
                 "A list of globs that match the authorization servers that this provider supports."
             ))
         }
@@ -67,7 +67,7 @@ const authenticationDefinitionSchema = {
 const authenticationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "authentication",
     jsonSchema: {
-        description: ( localize(14311, "Contributes authentication")),
+        description: ( localize(15437, "Contributes authentication")),
         type: "array",
         items: authenticationDefinitionSchema
     },
@@ -145,11 +145,11 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             added.forEach(point => {
                 for (const provider of point.value) {
                     if (isFalsyOrWhitespace(provider.id)) {
-                        point.collector.error(( localize(14312, "An authentication contribution must specify an id.")));
+                        point.collector.error(( localize(15438, "An authentication contribution must specify an id.")));
                         continue;
                     }
                     if (isFalsyOrWhitespace(provider.label)) {
-                        point.collector.error(( localize(14313, "An authentication contribution must specify a label.")));
+                        point.collector.error(( localize(15439, "An authentication contribution must specify a label.")));
                         continue;
                     }
                     if (!( this.declaredProviders.some(p => p.id === provider.id))) {
@@ -157,7 +157,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                         this._logService.debug(`Declared authentication provider: ${provider.id}`);
                     } else {
                         point.collector.error(( localize(
-                            14314,
+                            15440,
                             "This authentication id '{0}' has already been registered",
                             provider.id
                         )));
@@ -176,14 +176,14 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     registerDeclaredAuthenticationProvider(provider) {
         if (isFalsyOrWhitespace(provider.id)) {
-            throw ( new Error(( localize(14312, "An authentication contribution must specify an id."))));
+            throw ( new Error(( localize(15438, "An authentication contribution must specify an id."))));
         }
         if (isFalsyOrWhitespace(provider.label)) {
-            throw ( new Error(( localize(14313, "An authentication contribution must specify a label."))));
+            throw ( new Error(( localize(15439, "An authentication contribution must specify a label."))));
         }
         if (( this.declaredProviders.some(p => p.id === provider.id))) {
             throw ( new Error(( localize(
-                14314,
+                15440,
                 "This authentication id '{0}' has already been registered",
                 provider.id
             ))));