@codingame/monaco-vscode-api 26.0.1 → 26.1.0

package/vscode/src/vs/workbench/contrib/terminalContrib/typeAhead/common/terminalTypeAheadConfiguration.js

@@ -12,7 +12,7 @@ var TerminalTypeAheadSettingId;
 const terminalTypeAheadConfiguration = {
     [TerminalTypeAheadSettingId.LocalEchoLatencyThreshold]: {
         description: ( localize(
-            12736,
+            12737,
             "Length of network delay, in milliseconds, where local edits will be echoed on the terminal without waiting for server acknowledgement. If '0', local echo will always be on, and if '-1' it will be disabled."
         )),
         type: "integer",
@@ -22,19 +22,19 @@ const terminalTypeAheadConfiguration = {
     },
     [TerminalTypeAheadSettingId.LocalEchoEnabled]: {
         markdownDescription: ( localize(
-            12737,
+            12738,
             "When local echo should be enabled. This will override {0}",
             "`#terminal.integrated.localEchoLatencyThreshold#`"
         )),
         type: "string",
         enum: ["on", "off", "auto"],
-        enumDescriptions: [( localize(12738, "Always enabled")), ( localize(12739, "Always disabled")), ( localize(12740, "Enabled only for remote workspaces"))],
+        enumDescriptions: [( localize(12739, "Always enabled")), ( localize(12740, "Always disabled")), ( localize(12741, "Enabled only for remote workspaces"))],
         default: "off",
         tags: ["preview"]
     },
     [TerminalTypeAheadSettingId.LocalEchoExcludePrograms]: {
         description: ( localize(
-            12741,
+            12742,
             "Local echo will be disabled when any of these program names are found in the terminal title."
         )),
         type: "array",
@@ -47,7 +47,7 @@ const terminalTypeAheadConfiguration = {
     },
     [TerminalTypeAheadSettingId.LocalEchoStyle]: {
         description: ( localize(
-            12742,
+            12743,
             "Terminal style of locally echoed text; either a font style or an RGB color."
         )),
         default: "dim",

package/vscode/src/vs/workbench/contrib/terminalContrib/zoom/common/terminal.zoom.js

@@ -15,10 +15,10 @@ var TerminalZoomSettingId;
 const terminalZoomConfiguration = {
     [TerminalZoomSettingId.MouseWheelZoom]: {
         markdownDescription: isMacintosh ? ( localize(
-            12757,
+            12758,
             "Zoom the font of the terminal when using mouse wheel and holding `Cmd`."
         )) : ( localize(
-            12758,
+            12759,
             "Zoom the font of the terminal when using mouse wheel and holding `Ctrl`."
         )),
         type: "boolean",

package/vscode/src/vs/workbench/contrib/testing/common/constants.js

@@ -27,19 +27,19 @@ var TestExplorerViewSorting;
     TestExplorerViewSorting["ByDuration"] = "duration";
 })(TestExplorerViewSorting || (TestExplorerViewSorting = {}));
 const testStateNames = {
-    [TestResultState.Errored]: ( localize(13066, "Errored")),
-    [TestResultState.Failed]: ( localize(13067, "Failed")),
-    [TestResultState.Passed]: ( localize(13068, "Passed")),
-    [TestResultState.Queued]: ( localize(13069, "Queued")),
-    [TestResultState.Running]: ( localize(13070, "Running")),
-    [TestResultState.Skipped]: ( localize(13071, "Skipped")),
-    [TestResultState.Unset]: ( localize(13072, "Not yet run"))
+    [TestResultState.Errored]: ( localize(13067, "Errored")),
+    [TestResultState.Failed]: ( localize(13068, "Failed")),
+    [TestResultState.Passed]: ( localize(13069, "Passed")),
+    [TestResultState.Queued]: ( localize(13070, "Queued")),
+    [TestResultState.Running]: ( localize(13071, "Running")),
+    [TestResultState.Skipped]: ( localize(13072, "Skipped")),
+    [TestResultState.Unset]: ( localize(13073, "Not yet run"))
 };
-const labelForTestInState = (label, state) => ( localize(13073, "{0} ({1})", stripIcons(label), testStateNames[state]));
+const labelForTestInState = (label, state) => ( localize(13074, "{0} ({1})", stripIcons(label), testStateNames[state]));
 const testConfigurationGroupNames = {
-    [TestRunProfileBitset.Debug]: ( localize(13074, "Debug")),
-    [TestRunProfileBitset.Run]: ( localize(13075, "Run")),
-    [TestRunProfileBitset.Coverage]: ( localize(13076, "Coverage"))
+    [TestRunProfileBitset.Debug]: ( localize(13075, "Debug")),
+    [TestRunProfileBitset.Run]: ( localize(13076, "Run")),
+    [TestRunProfileBitset.Coverage]: ( localize(13077, "Coverage"))
 };
 var TestCommandId;
 (function(TestCommandId) {

package/vscode/src/vs/workbench/contrib/testing/common/testResult.js

@@ -168,7 +168,7 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         this.onNewTask = this.newTaskEmitter.event;
         this.onEndTask = this.endTaskEmitter.event;
         this.tasks = [];
-        this.name = ( localize(13077, "Test run at {0}", ( new Date()).toLocaleString(language)));
+        this.name = ( localize(13078, "Test run at {0}", ( new Date()).toLocaleString(language)));
         this.counts = makeEmptyCounts();
         this.computedStateAccessor = {
             getOwnState: i => i.ownComputedState,
@@ -430,7 +430,7 @@ class HydratedTestResult {
         this.completedAt = serialized.completedAt;
         this.tasks = ( serialized.tasks.map((task, i) => ({
             id: task.id,
-            name: task.name || ( localize(13078, "Unnamed Task")),
+            name: task.name || ( localize(13079, "Unnamed Task")),
             ctrlId: task.ctrlId,
             running: false,
             coverage: observableValue(this, undefined),

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.js

@@ -46,9 +46,9 @@ var TestRunProfileBitset;
     TestRunProfileBitset[TestRunProfileBitset["SupportsContinuousRun"] = 64] = "SupportsContinuousRun";
 })(TestRunProfileBitset || (TestRunProfileBitset = {}));
 const testProfileBitset = {
-    [TestRunProfileBitset.Run]: ( localize(13081, "Run")),
-    [TestRunProfileBitset.Debug]: ( localize(13082, "Debug")),
-    [TestRunProfileBitset.Coverage]: ( localize(13083, "Coverage"))
+    [TestRunProfileBitset.Run]: ( localize(13082, "Run")),
+    [TestRunProfileBitset.Debug]: ( localize(13083, "Debug")),
+    [TestRunProfileBitset.Coverage]: ( localize(13084, "Coverage"))
 };
 const testRunProfileBitsetList = [
     TestRunProfileBitset.Run,

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomains.js

@@ -50,7 +50,7 @@ async function openInEditor(editorService, resource) {
 const manageTrustedDomainSettingsCommand = {
     id: "workbench.action.manageTrustedDomain",
     description: {
-        description: ( localize2(13272, "Manage Trusted Domains")),
+        description: ( localize2(13273, "Manage Trusted Domains")),
         args: []
     },
     handler: async accessor => {
@@ -75,7 +75,7 @@ async function configureOpenerTrustedDomainsHandler(
     const options = [];
     options.push({
         type: "item",
-        label: ( localize(13273, "Trust {0}", domainToConfigure)),
+        label: ( localize(13274, "Trust {0}", domainToConfigure)),
         id: "trust",
         toTrust: domainToConfigure,
         picked: true
@@ -88,7 +88,7 @@ async function configureOpenerTrustedDomainsHandler(
             const base = parsedDomainToConfigure.authority.split(":")[0];
             options.push({
                 type: "item",
-                label: ( localize(13274, "Trust {0} on all ports", base)),
+                label: ( localize(13275, "Trust {0} on all ports", base)),
                 toTrust: base + ":*",
                 id: "trust"
             });
@@ -96,20 +96,20 @@ async function configureOpenerTrustedDomainsHandler(
     } else {
         options.push({
             type: "item",
-            label: ( localize(13275, "Trust {0} and all its subdomains", domainEnd)),
+            label: ( localize(13276, "Trust {0} and all its subdomains", domainEnd)),
             toTrust: topLevelDomain,
             id: "trust"
         });
     }
     options.push({
         type: "item",
-        label: ( localize(13276, "Trust all domains (disables link protection)")),
+        label: ( localize(13277, "Trust all domains (disables link protection)")),
         toTrust: "*",
         id: "trust"
     });
     options.push({
         type: "item",
-        label: ( localize(13277, "Manage Trusted Domains")),
+        label: ( localize(13278, "Manage Trusted Domains")),
         id: "manage"
     });
     const pickedResult = await quickInputService.pick(options, {

package/vscode/src/vs/workbench/contrib/webview/browser/webview.contribution.js

@@ -39,7 +39,7 @@ if (CutAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CutAction.id,
-            title: ( localize(13517, "Cut"))
+            title: ( localize(13518, "Cut"))
         },
         group: "5_cutcopypaste",
         order: 1,
@@ -50,7 +50,7 @@ if (CopyAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CopyAction.id,
-            title: ( localize(13518, "Copy"))
+            title: ( localize(13519, "Copy"))
         },
         group: "5_cutcopypaste",
         order: 2,
@@ -61,7 +61,7 @@ if (PasteAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: PasteAction.id,
-            title: ( localize(13519, "Paste"))
+            title: ( localize(13520, "Paste"))
         },
         group: "5_cutcopypaste",
         order: 3,

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -23,7 +23,7 @@ import { IWorkbenchLayoutService } from '../../../services/layout/browser/layout
 var WebviewEditor_1;
 const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( new RawContextKey("activeWebviewPanelId", "", {
     type: "string",
-    description: ( localize(13526, "The viewType of the currently active webview panel."))
+    description: ( localize(13527, "The viewType of the currently active webview panel."))
 }));
 let WebviewEditor = class WebviewEditor extends EditorPane {
     static {

package/vscode/src/vs/workbench/contrib/workspace/common/workspace.js

@@ -3,8 +3,8 @@ import { localize } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 
 const WorkspaceTrustContext = {
-    IsEnabled: ( new RawContextKey("isWorkspaceTrustEnabled", false, ( localize(13958, "Whether the workspace trust feature is enabled.")))),
-    IsTrusted: ( new RawContextKey("isWorkspaceTrusted", false, ( localize(13959, "Whether the current workspace has been trusted by the user."))))
+    IsEnabled: ( new RawContextKey("isWorkspaceTrustEnabled", false, ( localize(13959, "Whether the workspace trust feature is enabled.")))),
+    IsTrusted: ( new RawContextKey("isWorkspaceTrusted", false, ( localize(13960, "Whether the current workspace has been trusted by the user."))))
 };
 const MANAGE_TRUST_COMMAND_ID = "workbench.trust.manage";
 

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

@@ -16,7 +16,7 @@ import { ThrottledDelayer, RunOnceScheduler, timeout } from '../../../../base/co
 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 { isString } from '../../../../base/common/types.js';
+import { isUndefined, isString } from '../../../../base/common/types.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';
@@ -36,7 +36,7 @@ var DefaultAccountStatus;
 })(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 = 15 * 60 * 1000;
+const ACCOUNT_DATA_POLL_INTERVAL_MS = 60 * 60 * 1000;
 function toDefaultAccountConfig(defaultChatAgent) {
     return {
         preferredExtensions: [defaultChatAgent.chatExtensionId, defaultChatAgent.extensionId],
@@ -99,7 +99,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         this.onDidChangePolicyData = this._onDidChangePolicyData.event;
         this.initialized = false;
         this.updateThrottler = this._register(( new ThrottledDelayer(100)));
-        this.accountDataPollScheduler = this._register(( new RunOnceScheduler(() => this.updateDefaultAccount(), ACCOUNT_DATA_POLL_INTERVAL_MS)));
+        this.accountDataPollScheduler = this._register(( new RunOnceScheduler(() => this.refetchPolicyData(), ACCOUNT_DATA_POLL_INTERVAL_MS)));
         this.accountStatusContext = CONTEXT_DEFAULT_ACCOUNT_STATE.bindTo(contextKeyService);
         this._policyData = this.getCachedPolicyData();
         this.initPromise = this.init().finally(() => {
@@ -122,7 +122,9 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                     this.logService.debug("[DefaultAccount] Initializing with cached policy data");
                     return {
                         accountId,
-                        policyData
+                        policyData,
+                        isTokenEntitlementsDataFetched: false,
+                        isMcpRegistryDataFetched: false
                     };
                 }
             } catch (error) {
@@ -149,7 +151,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
         }
         this.logService.debug("[DefaultAccount] Starting initialization");
-        await this.doUpdateDefaultAccount();
+        await this.doUpdateDefaultAccount(false, false);
         this.logService.debug("[DefaultAccount] Initialization complete");
         this._register(this.onDidChangeDefaultAccount(account => {
             this.telemetryService.publicLog2("defaultaccount:status", {
@@ -204,28 +206,39 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             this.updateDefaultAccount();
         }));
         this._register(this.hostService.onDidChangeFocus(focused => {
-            if (focused && this._defaultAccount) {
+            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.updateDefaultAccount();
+                this.refresh(true);
             }
         }));
     }
-    async refresh() {
+    async refresh(donotFetchEntitlements = false) {
         if (!this.initialized) {
             await this.initPromise;
             return this.defaultAccount;
         }
         this.logService.debug("[DefaultAccount] Refreshing default account");
-        await this.updateDefaultAccount();
+        await this.updateDefaultAccount(false, donotFetchEntitlements);
         return this.defaultAccount;
     }
-    async updateDefaultAccount() {
-        await this.updateThrottler.trigger(() => this.doUpdateDefaultAccount());
+    async refetchPolicyData() {
+        if (!this.hostService.hasFocus) {
+            this.scheduleAccountDataPoll();
+            this.logService.debug(
+                "[DefaultAccount] Skipping refetching policy data because window is not focused"
+            );
+            return;
+        }
+        this.logService.debug("[DefaultAccount] Refetching policy data for current default account");
+        await this.updateDefaultAccount(true);
     }
-    async doUpdateDefaultAccount() {
+    async updateDefaultAccount(donotUseCache = false, donotFetchEntitlements = false) {
+        await this.updateThrottler.trigger(() => this.doUpdateDefaultAccount(donotUseCache, donotFetchEntitlements));
+    }
+    async doUpdateDefaultAccount(donotUseCache, donotFetchEntitlements) {
         try {
-            const defaultAccount = await this.fetchDefaultAccount();
+            const defaultAccount = await this.fetchDefaultAccount(donotUseCache, donotFetchEntitlements);
             this.setDefaultAccount(defaultAccount);
             this.scheduleAccountDataPoll();
         } catch (error) {
@@ -235,7 +248,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
         }
     }
-    async fetchDefaultAccount() {
+    async fetchDefaultAccount(donotUseCache, donotFetchEntitlements) {
         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);
@@ -246,7 +259,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
             return null;
         }
-        return await this.getDefaultAccountForAuthenticationProvider(defaultAccountProvider);
+        return await this.getDefaultAccountForAuthenticationProvider(defaultAccountProvider, donotUseCache, donotFetchEntitlements);
     }
     setDefaultAccount(account) {
         if (equals(this._defaultAccount, account)) {
@@ -312,7 +325,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         );
         return result;
     }
-    async getDefaultAccountForAuthenticationProvider(authenticationProvider) {
+    async getDefaultAccountForAuthenticationProvider(authenticationProvider, donotUseCache, donotFetchEntitlements) {
         try {
             this.logService.debug(
                 "[DefaultAccount] Getting Default Account from authenticated sessions for provider:",
@@ -329,7 +342,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                 );
                 return null;
             }
-            return this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions);
+            return this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, donotUseCache, donotFetchEntitlements);
         } catch (error) {
             this.logService.error(
                 "[DefaultAccount] Failed to get default account for provider:",
@@ -339,24 +352,35 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             return null;
         }
     }
-    async getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions) {
+    async getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, donotUseCache, donotFetchEntitlements) {
         try {
             const accountId = sessions[0].account.id;
-            const [entitlementsData, tokenEntitlementsData] = await Promise.all([this.getEntitlements(sessions), this.getTokenEntitlements(sessions)]);
-            let policyData = this._policyData?.accountId === accountId ? {
-                ...this._policyData.policyData
+            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)
+            ]);
+            let isTokenEntitlementsDataFetched = false;
+            let isMcpRegistryDataFetched = false;
+            let policyData = accountPolicyData?.policyData ? {
+                ...accountPolicyData.policyData
             } : undefined;
             if (tokenEntitlementsData) {
+                isTokenEntitlementsDataFetched = true;
                 policyData = policyData ?? {};
                 policyData.chat_agent_enabled = tokenEntitlementsData.chat_agent_enabled;
                 policyData.chat_preview_features_enabled = tokenEntitlementsData.chat_preview_features_enabled;
                 policyData.mcp = tokenEntitlementsData.mcp;
                 if (policyData.mcp) {
-                    const mcpRegistryProvider = await this.getMcpRegistryProvider(sessions);
-                    if (mcpRegistryProvider) {
-                        policyData.mcpRegistryUrl = mcpRegistryProvider.url;
-                        policyData.mcpAccess = mcpRegistryProvider.registry_access;
+                    const mcpRegistryProvider = await this.getMcpRegistryProvider(sessions, donotUseCache ? undefined : accountPolicyData);
+                    if (!isUndefined(mcpRegistryProvider)) {
+                        isMcpRegistryDataFetched = true;
+                        policyData.mcpRegistryUrl = mcpRegistryProvider?.url;
+                        policyData.mcpAccess = mcpRegistryProvider?.registry_access;
                     }
+                } else {
+                    policyData.mcpRegistryUrl = undefined;
+                    policyData.mcpAccess = undefined;
                 }
             }
             const defaultAccount = {
@@ -373,7 +397,9 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                 defaultAccount,
                 policyData: policyData ? {
                     accountId,
-                    policyData
+                    policyData,
+                    isTokenEntitlementsDataFetched,
+                    isMcpRegistryDataFetched
                 } : null
             };
         } catch (error) {
@@ -434,7 +460,14 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
     scopesMatch(scopes, expectedScopes) {
         return expectedScopes.every(scope => scopes.includes(scope));
     }
-    async getTokenEntitlements(sessions) {
+    async getTokenEntitlements(sessions, accountPolicyData) {
+        if (accountPolicyData?.isTokenEntitlementsDataFetched) {
+            this.logService.debug("[DefaultAccount] Using last fetched token entitlements data");
+            return accountPolicyData.policyData;
+        }
+        return await this.requestTokenEntitlements(sessions);
+    }
+    async requestTokenEntitlements(sessions) {
         const tokenEntitlementsUrl = this.getTokenEntitlementUrl();
         if (!tokenEntitlementsUrl) {
             this.logService.debug("[DefaultAccount] No token entitlements URL found");
@@ -498,11 +531,21 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         }
         return undefined;
     }
-    async getMcpRegistryProvider(sessions) {
+    async getMcpRegistryProvider(sessions, accountPolicyData) {
+        if (accountPolicyData?.isMcpRegistryDataFetched) {
+            this.logService.debug("[DefaultAccount] Using last fetched MCP registry data");
+            return accountPolicyData.policyData.mcpRegistryUrl && accountPolicyData.policyData.mcpAccess ? {
+                url: accountPolicyData.policyData.mcpRegistryUrl,
+                registry_access: accountPolicyData.policyData.mcpAccess
+            } : null;
+        }
+        return await this.requestMcpRegistryProvider(sessions);
+    }
+    async requestMcpRegistryProvider(sessions) {
         const mcpRegistryDataUrl = this.getMcpRegistryDataUrl();
         if (!mcpRegistryDataUrl) {
             this.logService.debug("[DefaultAccount] No MCP registry data URL found");
-            return undefined;
+            return null;
         }
         this.logService.debug("[DefaultAccount] Fetching MCP registry data from:", mcpRegistryDataUrl);
         const response = await this.request(mcpRegistryDataUrl, "GET", undefined, sessions, CancellationToken.None);
@@ -510,7 +553,25 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             return undefined;
         }
         if (response.res.statusCode && response.res.statusCode !== 200) {
-            this.logService.trace(
+            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) {
+                this.logService.debug(
+                    `[DefaultAccount] Received 429 Too Many Requests for MCP registry data, treating as no registry available and not retrying immediately.`
+                );
+                return null;
+            }
+            this.logService.debug(
                 `[DefaultAccount] unexpected status code ${response.res.statusCode} while fetching MCP registry data`
             );
             return undefined;
@@ -519,13 +580,14 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             const data = await asJson(response);
             if (data) {
                 this.logService.debug("Fetched MCP registry providers", data.mcp_registries);
-                return data.mcp_registries[0];
+                return data.mcp_registries[0] ?? null;
             }
-            this.logService.debug("Failed to fetch MCP registry providers", "No data returned");
+            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;
         }
-        return undefined;
     }
     async request(url, type, body, sessions, token) {
         let lastResponse;
@@ -545,13 +607,17 @@ 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;
+                    }
                     lastResponse = response;
                     continue;
                 }
                 return response;
             } catch (error) {
                 if (!token.isCancellationRequested) {
-                    this.logService.error(`[chat entitlement] request: error ${error}`);
+                    this.logService.error(`[DefaultAccount] request: error ${error}`, url);
                 }
             }
         }
@@ -559,13 +625,6 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             this.logService.trace("[DefaultAccount]: No response received for request", url);
             return undefined;
         }
-        if (lastResponse.res.statusCode && lastResponse.res.statusCode !== 200) {
-            this.logService.trace(
-                `[DefaultAccount]: unexpected status code ${lastResponse.res.statusCode} for request`,
-                url
-            );
-            return undefined;
-        }
         return lastResponse;
     }
     getEntitlementUrl() {

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

@@ -42,23 +42,23 @@ const authenticationDefinitionSchema = {
     properties: {
         id: {
             type: "string",
-            description: ( localize(14116, "The id of the authentication provider."))
+            description: ( localize(14117, "The id of the authentication provider."))
         },
         label: {
             type: "string",
-            description: ( localize(14117, "The human readable name of the authentication provider."))
+            description: ( localize(14118, "The human readable name of the authentication provider."))
         },
         authorizationServerGlobs: {
             type: "array",
             items: {
                 type: "string",
                 description: ( localize(
-                    14118,
+                    14119,
                     "A list of globs that match the authorization servers that this provider supports."
                 ))
             },
             description: ( localize(
-                14119,
+                14120,
                 "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(14120, "Contributes authentication")),
+        description: ( localize(14121, "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(14121, "An authentication contribution must specify an id.")));
+                        point.collector.error(( localize(14122, "An authentication contribution must specify an id.")));
                         continue;
                     }
                     if (isFalsyOrWhitespace(provider.label)) {
-                        point.collector.error(( localize(14122, "An authentication contribution must specify a label.")));
+                        point.collector.error(( localize(14123, "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(
-                            14123,
+                            14124,
                             "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(14121, "An authentication contribution must specify an id."))));
+            throw ( new Error(( localize(14122, "An authentication contribution must specify an id."))));
         }
         if (isFalsyOrWhitespace(provider.label)) {
-            throw ( new Error(( localize(14122, "An authentication contribution must specify a label."))));
+            throw ( new Error(( localize(14123, "An authentication contribution must specify a label."))));
         }
         if (( this.declaredProviders.some(p => p.id === provider.id))) {
             throw ( new Error(( localize(
-                14123,
+                14124,
                 "This authentication id '{0}' has already been registered",
                 provider.id
             ))));

package/vscode/src/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.js

@@ -137,7 +137,7 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
     preventUnload(e) {
         e.preventDefault();
         e.returnValue = ( localize(
-            14124,
+            14125,
             "Changes that you made may not be saved. Please check press 'Cancel' and try again."
         ));
     }
@@ -205,7 +205,7 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         mark("code/auxiliaryWindow/willOpen");
         const targetWindow = await this.openWindow(options);
         if (!targetWindow) {
-            throw ( new Error(( localize(14125, "Unable to open a new window."))));
+            throw ( new Error(( localize(14126, "Unable to open a new window."))));
         }
         const resolvedWindowId = await this.resolveWindowId(targetWindow);
         ensureCodeWindow(targetWindow, resolvedWindowId);
@@ -296,20 +296,20 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
             return (await this.dialogService.prompt({
                 type: Severity$1.Warning,
                 message: ( localize(
-                    14126,
+                    14127,
                     "The browser blocked opening a new window. Press 'Retry' to try again."
                 )),
                 custom: {
                     markdownDetails: [{
                         markdown: ( new MarkdownString(( localize(
-                            14127,
+                            14128,
                             "Please allow pop-ups for this website in your [browser settings]({0}).",
                             "https://aka.ms/allow-vscode-popup"
                         )), true))
                     }]
                 },
                 buttons: [{
-                    label: ( localize(14128, "&&Retry")),
+                    label: ( localize(14129, "&&Retry")),
                     run: () => this.openWindow(options)
                 }],
                 cancelButton: true