@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/platform/localTranscription/common/localTranscription.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const ILocalTranscriptionService = ( createDecorator("localTranscriptionService"));
+
+export { ILocalTranscriptionService };

package/vscode/src/vs/platform/log/common/log.d.ts

@@ -178,10 +178,10 @@ export declare abstract class AbstractLoggerService extends Disposable implement
         removed: ILoggerResource[];
     }>;
     private _onDidChangeLogLevel;
-    readonly onDidChangeLogLevel: Event<LogLevel | [
+    readonly onDidChangeLogLevel: Event<[
         URI,
         LogLevel
-    ]>;
+    ] | LogLevel>;
     private _onDidChangeVisibility;
     readonly onDidChangeVisibility: Event<[
         URI,

package/vscode/src/vs/platform/log/common/log.js

@@ -461,32 +461,32 @@ function LogLevelToLocalizedString(logLevel) {
     case LogLevel.Trace:
         return {
             original: "Trace",
-            value: ( localize(2166, "Trace"))
+            value: ( localize(2384, "Trace"))
         };
     case LogLevel.Debug:
         return {
             original: "Debug",
-            value: ( localize(2167, "Debug"))
+            value: ( localize(2385, "Debug"))
         };
     case LogLevel.Info:
         return {
             original: "Info",
-            value: ( localize(2168, "Info"))
+            value: ( localize(2386, "Info"))
         };
     case LogLevel.Warning:
         return {
             original: "Warning",
-            value: ( localize(2169, "Warning"))
+            value: ( localize(2387, "Warning"))
         };
     case LogLevel.Error:
         return {
             original: "Error",
-            value: ( localize(2170, "Error"))
+            value: ( localize(2388, "Error"))
         };
     case LogLevel.Off:
         return {
             original: "Off",
-            value: ( localize(2171, "Off"))
+            value: ( localize(2389, "Off"))
         };
     }
 }

package/vscode/src/vs/platform/markers/common/markerService.js

@@ -271,8 +271,8 @@ class MarkerService {
         }
     }
     _createFilteredMarker(resource, reasons) {
-        const message = reasons.length === 1 ? ( localize(2172, "Problems are paused because: \"{0}\"", reasons[0])) : ( localize(
-            2173,
+        const message = reasons.length === 1 ? ( localize(2390, "Problems are paused because: \"{0}\"", reasons[0])) : ( localize(
+            2391,
             "Problems are paused because: \"{0}\" and {1} more",
             reasons[0],
             reasons.length - 1

package/vscode/src/vs/platform/markers/common/markers.js

@@ -20,17 +20,17 @@ var MarkerSeverity;
     }
     MarkerSeverity.compare = compare;
     const _displayStrings = Object.create(null);
-    _displayStrings[MarkerSeverity.Error] = ( localize(2174, "Error"));
-    _displayStrings[MarkerSeverity.Warning] = ( localize(2175, "Warning"));
-    _displayStrings[MarkerSeverity.Info] = ( localize(2176, "Info"));
+    _displayStrings[MarkerSeverity.Error] = ( localize(2392, "Error"));
+    _displayStrings[MarkerSeverity.Warning] = ( localize(2393, "Warning"));
+    _displayStrings[MarkerSeverity.Info] = ( localize(2394, "Info"));
     function toString(a) {
         return _displayStrings[a] || "";
     }
     MarkerSeverity.toString = toString;
     const _displayStringsPlural = Object.create(null);
-    _displayStringsPlural[MarkerSeverity.Error] = ( localize(2177, "Errors"));
-    _displayStringsPlural[MarkerSeverity.Warning] = ( localize(2178, "Warnings"));
-    _displayStringsPlural[MarkerSeverity.Info] = ( localize(2179, "Infos"));
+    _displayStringsPlural[MarkerSeverity.Error] = ( localize(2395, "Errors"));
+    _displayStringsPlural[MarkerSeverity.Warning] = ( localize(2396, "Warnings"));
+    _displayStringsPlural[MarkerSeverity.Info] = ( localize(2397, "Infos"));
     function toStringPlural(a) {
         return _displayStringsPlural[a] || "";
     }

package/vscode/src/vs/platform/mcp/common/mcpManagement.d.ts

@@ -137,6 +137,22 @@ export interface IQueryOptions {
     sortBy?: SortBy;
     sortOrder?: SortOrder;
 }
+export declare enum McpGalleryResolveStatus {
+    /** The server was found in the active registry. */
+    Found = 0,
+    /** The active registry authoritatively does not contain the server. */
+    NotFound = 1,
+    /** Membership could not be determined (e.g. registry unreachable). */
+    Failed = 2
+}
+export type IMcpGalleryServerResolveResult = {
+    readonly status: McpGalleryResolveStatus.Found;
+    readonly server: IGalleryMcpServer;
+} | {
+    readonly status: McpGalleryResolveStatus.NotFound;
+} | {
+    readonly status: McpGalleryResolveStatus.Failed;
+};
 export interface InstallMcpServerEvent {
     readonly name: string;
     readonly mcpResource: URI;
@@ -176,6 +192,8 @@ export interface McpServerConfigurationParseResult {
     readonly notices: string[];
 }
 export declare const mcpAccessConfig = "chat.mcp.access";
+export declare const mcpAllowedServersConfig = "chat.mcp.allowedServers";
+export declare const mcpDeniedServersConfig = "chat.mcp.deniedServers";
 export declare const mcpGalleryServiceUrlConfig = "chat.mcp.gallery.serviceUrl";
 export declare const mcpGalleryServiceEnablementConfig = "chat.mcp.gallery.enabled";
 export declare const mcpAutoStartConfig = "chat.mcp.autostart";

package/vscode/src/vs/platform/mcp/common/mcpManagement.js

@@ -20,7 +20,15 @@ var GalleryMcpServerStatus;
     GalleryMcpServerStatus["Active"] = "active";
     GalleryMcpServerStatus["Deprecated"] = "deprecated";
 })(GalleryMcpServerStatus || (GalleryMcpServerStatus = {}));
+var McpGalleryResolveStatus;
+(function (McpGalleryResolveStatus) {
+    McpGalleryResolveStatus[McpGalleryResolveStatus["Found"] = 0] = "Found";
+    McpGalleryResolveStatus[McpGalleryResolveStatus["NotFound"] = 1] = "NotFound";
+    McpGalleryResolveStatus[McpGalleryResolveStatus["Failed"] = 2] = "Failed";
+})(McpGalleryResolveStatus || (McpGalleryResolveStatus = {}));
 const mcpAccessConfig = 'chat.mcp.access';
+const mcpAllowedServersConfig = 'chat.mcp.allowedServers';
+const mcpDeniedServersConfig = 'chat.mcp.deniedServers';
 const mcpGalleryServiceUrlConfig = 'chat.mcp.gallery.serviceUrl';
 const mcpGalleryServiceEnablementConfig = 'chat.mcp.gallery.enabled';
 const mcpAutoStartConfig = 'chat.mcp.autostart';
@@ -38,4 +46,4 @@ var McpAccessValue;
     McpAccessValue["All"] = "all";
 })(McpAccessValue || (McpAccessValue = {}));
 
-export { GalleryMcpServerStatus, McpAccessValue, McpAutoStartValue, RegistryType, TransportType, mcpAccessConfig, mcpAppsEnabledConfig, mcpAutoStartConfig, mcpGalleryServiceEnablementConfig, mcpGalleryServiceUrlConfig };
+export { GalleryMcpServerStatus, McpAccessValue, McpAutoStartValue, McpGalleryResolveStatus, RegistryType, TransportType, mcpAccessConfig, mcpAllowedServersConfig, mcpAppsEnabledConfig, mcpAutoStartConfig, mcpDeniedServersConfig, mcpGalleryServiceEnablementConfig, mcpGalleryServiceUrlConfig };

package/vscode/src/vs/platform/mcp/common/mcpManagement.service.d.ts

@@ -3,7 +3,8 @@ import { Event } from "../../../base/common/event.js";
 import { IMarkdownString } from "../../../base/common/htmlContent.js";
 import { IIterativePager } from "../../../base/common/paging.js";
 import { URI } from "../../../base/common/uri.js";
-import { IQueryOptions, IGalleryMcpServer, type DidUninstallMcpServerEvent, type IGalleryMcpServerConfiguration, type IInstallableMcpServer, type ILocalMcpServer, type InstallMcpServerEvent, type InstallMcpServerResult, type InstallOptions, type McpServerConfigurationParseResult, type RegistryType, type UninstallMcpServerEvent, type UninstallOptions } from "./mcpManagement.js";
+import { IMcpServerIdentity } from "@codingame/monaco-vscode-mcp-service-override/vscode/vs/platform/mcp/common/allowedMcpServers";
+import { IQueryOptions, IGalleryMcpServer, IMcpGalleryServerResolveResult, type DidUninstallMcpServerEvent, type IGalleryMcpServerConfiguration, type IInstallableMcpServer, type ILocalMcpServer, type InstallMcpServerEvent, type InstallMcpServerResult, type InstallOptions, type McpServerConfigurationParseResult, type RegistryType, type UninstallMcpServerEvent, type UninstallOptions } from "./mcpManagement.js";
 export declare const IMcpGalleryService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IMcpGalleryService>;
 export interface IMcpGalleryService {
     readonly _serviceBrand: undefined;
@@ -13,6 +14,16 @@ export interface IMcpGalleryService {
         name: string;
         id?: string;
     }[]): Promise<IGalleryMcpServer[]>;
+    /**
+    * Resolves the given servers against the active registry, distinguishing a
+    * definitive "not found" from a transient failure so callers can make policy
+    * decisions without treating an unreachable registry as absence. The returned
+    * map is keyed by the requested server name.
+    */
+    resolveMcpServersFromGallery(infos: {
+        name: string;
+        id?: string;
+    }[]): Promise<Map<string, IMcpGalleryServerResolveResult>>;
     getMcpServer(url: string): Promise<IGalleryMcpServer | undefined>;
     getReadme(extension: IGalleryMcpServer, token: CancellationToken): Promise<string>;
 }
@@ -37,4 +48,10 @@ export interface IAllowedMcpServersService {
     readonly _serviceBrand: undefined;
     readonly onDidChangeAllowedMcpServers: Event<void>;
     isAllowed(mcpServer: IGalleryMcpServer | ILocalMcpServer | IInstallableMcpServer): true | IMarkdownString;
+    /**
+    * Checks whether an MCP server identified by name / remote URL / local command is permitted by
+    * the `chat.mcp.allowedServers` allowlist (in addition to the `chat.mcp.access` gate). Used by
+    * the runtime enforcement path, which does not have a gallery/local/installable representation.
+    */
+    isServerAllowed(identity: IMcpServerIdentity): true | IMarkdownString;
 }

package/vscode/src/vs/platform/mcp/common/mcpManagementService.d.ts

@@ -63,6 +63,7 @@ export declare abstract class AbstractMcpResourceManagementService extends Abstr
     protected readonly fileService: IFileService;
     protected readonly uriIdentityService: IUriIdentityService;
     protected readonly mcpResourceScannerService: IMcpResourceScannerService;
+    protected readonly allowedMcpServersService: IAllowedMcpServersService;
     private initializePromise;
     private readonly reloadConfigurationScheduler;
     private local;
@@ -76,11 +77,19 @@ export declare abstract class AbstractMcpResourceManagementService extends Abstr
     get onUninstallMcpServer(): Event<UninstallMcpServerEvent>;
     protected _onDidUninstallMcpServer: Emitter<DidUninstallMcpServerEvent>;
     get onDidUninstallMcpServer(): Event<DidUninstallMcpServerEvent>;
-    constructor(mcpResource: URI, target: McpResourceTarget, mcpGalleryService: IMcpGalleryService, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService, mcpResourceScannerService: IMcpResourceScannerService);
+    constructor(mcpResource: URI, target: McpResourceTarget, mcpGalleryService: IMcpGalleryService, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService, mcpResourceScannerService: IMcpResourceScannerService, allowedMcpServersService: IAllowedMcpServersService);
+    /**
+     * Enforces the enterprise allow/deny policy at the point of persistence. Called by every
+     * install path (installable and each gallery override) against the fully resolved server
+     * configuration, so a caller that goes straight to the management API cannot bypass the
+     * `canInstall` UI check, and a gallery entry cannot slip through if its resolved command/URL
+     * differs from the pre-resolution metadata.
+     */
+    protected ensureServerAllowed(server: IGalleryMcpServer | IInstallableMcpServer): void;
     private initialize;
     private populateLocalServers;
     private startWatching;
-    protected updateLocal(): Promise<void>;
+    protected updateLocal(source?: IGalleryMcpServer): Promise<void>;
     getInstalled(): Promise<ILocalMcpServer[]>;
     protected scanLocalServer(name: string, config: IMcpServerConfiguration, rootSandbox?: IMcpSandboxConfiguration): Promise<ILocalMcpServer>;
     install(server: IInstallableMcpServer, options?: Omit<InstallOptions, "mcpResource">): Promise<ILocalMcpServer>;
@@ -90,8 +99,9 @@ export declare abstract class AbstractMcpResourceManagementService extends Abstr
 }
 export declare class McpUserResourceManagementService extends AbstractMcpResourceManagementService {
     protected readonly mcpLocation: URI;
-    constructor(mcpResource: URI, mcpGalleryService: IMcpGalleryService, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService, mcpResourceScannerService: IMcpResourceScannerService, environmentService: IEnvironmentService);
+    constructor(mcpResource: URI, mcpGalleryService: IMcpGalleryService, fileService: IFileService, uriIdentityService: IUriIdentityService, logService: ILogService, mcpResourceScannerService: IMcpResourceScannerService, allowedMcpServersService: IAllowedMcpServersService, environmentService: IEnvironmentService);
     installFromGallery(server: IGalleryMcpServer, options?: InstallOptions): Promise<ILocalMcpServer>;
+    uninstall(server: ILocalMcpServer, options?: Omit<UninstallOptions, "mcpResource">): Promise<void>;
     updateMetadata(local: ILocalMcpServer, gallery: IGalleryMcpServer): Promise<ILocalMcpServer>;
     protected updateMetadataFromGallery(gallery: IGalleryMcpServer): Promise<IGalleryMcpServerConfiguration>;
     protected getLocalServerInfo(name: string, mcpServerConfig: IMcpServerConfiguration): Promise<ILocalMcpServerInfo | undefined>;

package/vscode/src/vs/platform/mcp/common/mcpManagementService.js

@@ -13,6 +13,7 @@ import { URI } from '../../../base/common/uri.js';
 import { localize } from '../../../nls.js';
 import { ConfigurationTarget } from '../../configuration/common/configuration.js';
 import { IEnvironmentService } from '../../environment/common/environment.service.js';
+import { toFileOperationResult, FileOperationResult } from '../../files/common/files.js';
 import { IFileService } from '../../files/common/files.service.js';
 import { IInstantiationService } from '../../instantiation/common/instantiation.js';
 import { ILogService } from '../../log/common/log.service.js';
@@ -152,8 +153,9 @@ let AbstractCommonMcpManagementService = class AbstractCommonMcpManagementServic
             return "uvx";
         case RegistryType.NUGET:
             return "dnx";
+        default:
+            throw ( new Error(`Unsupported MCP server package registry type: ${packageType}`));
         }
-        return packageType;
     }
     getVariables(variableInputs) {
         const variables = [];
@@ -284,7 +286,8 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
         fileService,
         uriIdentityService,
         logService,
-        mcpResourceScannerService
+        mcpResourceScannerService,
+        allowedMcpServersService
     ) {
         super(logService);
         this.mcpResource = mcpResource;
@@ -293,6 +296,7 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
         this.fileService = fileService;
         this.uriIdentityService = uriIdentityService;
         this.mcpResourceScannerService = mcpResourceScannerService;
+        this.allowedMcpServersService = allowedMcpServersService;
         this.local = ( new Map());
         this._onInstallMcpServer = this._register(( new Emitter()));
         this.onInstallMcpServer = this._onInstallMcpServer.event;
@@ -302,6 +306,12 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
         this._onDidUninstallMcpServer = this._register(( new Emitter()));
         this.reloadConfigurationScheduler = this._register(( new RunOnceScheduler(() => this.updateLocal(), 50)));
     }
+    ensureServerAllowed(server) {
+        const result = this.allowedMcpServersService.isAllowed(server);
+        if (result !== true) {
+            throw ( new Error(result.value));
+        }
+    }
     initialize() {
         if (!this.initializePromise) {
             this.initializePromise = (async () => {
@@ -342,7 +352,7 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
             }
         }));
     }
-    async updateLocal() {
+    async updateLocal(source) {
         try {
             const current = await this.populateLocalServers();
             const added = [];
@@ -374,6 +384,7 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
                 this._onDidUpdateMcpServers.fire(( updated.map(server => ({
                     name: server.name,
                     local: server,
+                    source: source?.name === server.name ? source : undefined,
                     mcpResource: this.mcpResource
                 }))));
             }
@@ -381,6 +392,7 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
                 this._onDidInstallMcpServers.fire(( added.map(server => ({
                     name: server.name,
                     local: server,
+                    source: source?.name === server.name ? source : undefined,
                     mcpResource: this.mcpResource
                 }))));
             }
@@ -424,6 +436,7 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
     }
     async install(server, options) {
         this.logService.trace("MCP Management Service: install", server.name);
+        this.ensureServerAllowed(server);
         this._onInstallMcpServer.fire({
             name: server.name,
             mcpResource: this.mcpResource
@@ -473,7 +486,7 @@ let AbstractMcpResourceManagementService = class AbstractMcpResourceManagementSe
         }
     }
 };
-AbstractMcpResourceManagementService = ( __decorate([( __param(2, IMcpGalleryService)), ( __param(3, IFileService)), ( __param(4, IUriIdentityService)), ( __param(5, ILogService)), ( __param(6, IMcpResourceScannerService))], AbstractMcpResourceManagementService));
+AbstractMcpResourceManagementService = ( __decorate([( __param(2, IMcpGalleryService)), ( __param(3, IFileService)), ( __param(4, IUriIdentityService)), ( __param(5, ILogService)), ( __param(6, IMcpResourceScannerService)), ( __param(7, IAllowedMcpServersService))], AbstractMcpResourceManagementService));
 let McpUserResourceManagementService = class McpUserResourceManagementService extends AbstractMcpResourceManagementService {
     constructor(
         mcpResource,
@@ -482,6 +495,7 @@ let McpUserResourceManagementService = class McpUserResourceManagementService ex
         uriIdentityService,
         logService,
         mcpResourceScannerService,
+        allowedMcpServersService,
         environmentService
     ) {
         super(
@@ -491,16 +505,23 @@ let McpUserResourceManagementService = class McpUserResourceManagementService ex
             fileService,
             uriIdentityService,
             logService,
-            mcpResourceScannerService
+            mcpResourceScannerService,
+            allowedMcpServersService
         );
         this.mcpLocation = uriIdentityService.extUri.joinPath(environmentService.userRoamingDataHome, "mcp");
     }
     async installFromGallery(server, options) {
         throw ( new Error("Not supported"));
     }
+    async uninstall(server, options) {
+        if (server.location && !this.uriIdentityService.extUri.isEqual(URI.revive(server.location), this.getLocation(server.name, server.version))) {
+            throw ( new Error(`Invalid MCP server location for ${server.name}`));
+        }
+        await super.uninstall(server, options);
+    }
     async updateMetadata(local, gallery) {
         await this.updateMetadataFromGallery(gallery);
-        await this.updateLocal();
+        await this.updateLocal(gallery);
         const updatedLocal = (await this.getInstalled()).find(s => s.name === local.name);
         if (!updatedLocal) {
             throw ( new Error(`Failed to find MCP server: ${local.name}`));
@@ -557,14 +578,22 @@ let McpUserResourceManagementService = class McpUserResourceManagementService ex
                 }
                 storedMcpServerInfo.readmeUrl = readmeUrl;
             } catch (e) {
-                this.logService.error("MCP Management Service: failed to read manifest", ( location.toString()), e);
+                if (toFileOperationResult(e) === FileOperationResult.FILE_NOT_FOUND) {
+                    this.logService.trace("MCP Management Service: manifest not found", ( manifestLocation.toString()));
+                } else {
+                    this.logService.error("MCP Management Service: failed to read manifest", ( location.toString()), e);
+                }
             }
         }
         return storedMcpServerInfo;
     }
     getLocation(name, version) {
-        name = name.replace("/", ".");
-        return this.uriIdentityService.extUri.joinPath(this.mcpLocation, version ? `${name}-${version}` : name);
+        const folderName = version ? `${name.replace("/", ".")}-${version}` : name.replace("/", ".");
+        const location = this.uriIdentityService.extUri.joinPath(this.mcpLocation, folderName);
+        if (this.uriIdentityService.extUri.basename(location) !== folderName || this.uriIdentityService.extUri.isEqual(location, this.mcpLocation) || !this.uriIdentityService.extUri.isEqualOrParent(location, this.mcpLocation)) {
+            throw ( new Error(`Invalid MCP server location for ${name}`));
+        }
+        return location;
     }
     installFromUri(uri, options) {
         throw ( new Error("Method not supported."));
@@ -573,7 +602,7 @@ let McpUserResourceManagementService = class McpUserResourceManagementService ex
         throw ( new Error("Not supported"));
     }
 };
-McpUserResourceManagementService = ( __decorate([( __param(1, IMcpGalleryService)), ( __param(2, IFileService)), ( __param(3, IUriIdentityService)), ( __param(4, ILogService)), ( __param(5, IMcpResourceScannerService)), ( __param(6, IEnvironmentService))], McpUserResourceManagementService));
+McpUserResourceManagementService = ( __decorate([( __param(1, IMcpGalleryService)), ( __param(2, IFileService)), ( __param(3, IUriIdentityService)), ( __param(4, ILogService)), ( __param(5, IMcpResourceScannerService)), ( __param(6, IAllowedMcpServersService)), ( __param(7, IEnvironmentService))], McpUserResourceManagementService));
 let AbstractMcpManagementService = class AbstractMcpManagementService extends AbstractCommonMcpManagementService {
     constructor(allowedMcpServersService, logService) {
         super(logService);
@@ -583,7 +612,7 @@ let AbstractMcpManagementService = class AbstractMcpManagementService extends Ab
         const allowedToInstall = this.allowedMcpServersService.isAllowed(server);
         if (allowedToInstall !== true) {
             return (new MarkdownString(localize(
-                2183,
+                2403,
                 "This mcp server cannot be installed because {0}",
                 allowedToInstall.value
             )));

package/vscode/src/vs/platform/mcp/common/mcpPlatformTypes.d.ts

@@ -58,6 +58,7 @@ export interface IMcpRemoteServerOAuthConfiguration {
 }
 export interface IMcpRemoteServerConfiguration extends ICommonMcpServerConfiguration {
     readonly type: McpServerType.REMOTE;
+    readonly transport?: "http" | "sse";
     readonly url: string;
     readonly headers?: Record<string, string>;
     readonly oauth?: IMcpRemoteServerOAuthConfiguration;

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.config.contribution.js

@@ -7,23 +7,23 @@ const configurationRegistry = ( Registry.as(Extensions.Configuration));
 configurationRegistry.registerConfiguration({
     id: "network",
     order: 14,
-    title: ( localize(2184, "Network")),
+    title: ( localize(2404, "Network")),
     type: "object",
     properties: {
         "network.meteredConnection": {
             type: "string",
             enum: ["auto", "on", "off"],
             enumDescriptions: [( localize(
-                2185,
+                2405,
                 "Automatically detect metered connections using the operating system's network status."
             )), ( localize(
-                2186,
+                2406,
                 "Always treat the network connection as metered. Automatic updates and downloads will be postponed."
-            )), ( localize(2187, "Never treat the network connection as metered."))],
+            )), ( localize(2407, "Never treat the network connection as metered."))],
             default: "auto",
             scope: ConfigurationScope.APPLICATION,
             description: ( localize(
-                2188,
+                2408,
                 "Controls whether the current network connection should be treated as metered. When metered, automatic updates, extension downloads, and other background network activity will be postponed to reduce data usage."
             )),
             tags: ["usesOnlineServices"]

package/vscode/src/vs/platform/meteredConnection/common/meteredConnection.service.d.ts

@@ -12,6 +12,10 @@ export interface IMeteredConnectionService {
     */
     readonly isConnectionMetered: boolean;
     /**
+    * Resolves once the initial connection state is available, when initialization is asynchronous.
+    */
+    readonly whenConnectionStateInitialized?: Promise<void>;
+    /**
     * Event that fires when the metered connection status changes.
     */
     readonly onDidChangeIsConnectionMetered: Event<boolean>;

package/vscode/src/vs/platform/native/common/native.d.ts

@@ -7,9 +7,13 @@ import { INativeOpenDialogOptions } from "../../dialogs/common/dialogs.js";
 import { IV8Profile } from "../../profiling/common/profiling.js";
 import { AuthInfo, Credentials } from "../../request/common/request.js";
 import { IPartsSplash } from "../../theme/common/themeService.js";
-import { IColorScheme, IOpenedAuxiliaryWindow, IOpenedMainWindow, IOpenEmptyWindowOptions, IOpenWindowOptions, IPoint, IRectangle, IWindowOpenable } from "../../window/common/window.js";
+import { AgentsWindowOpenSource, IColorScheme, IOpenedAuxiliaryWindow, IOpenedMainWindow, IOpenEmptyWindowOptions, IOpenWindowOptions, IPoint, IRectangle, IWindowOpenable } from "../../window/common/window.js";
 export interface IToastOptions {
     readonly id: string;
+    /**
+     * Prevents another live toast with the same key from being shown.
+     */
+    readonly dedupeKey?: string;
     readonly title: string;
     readonly body?: string;
     readonly actions?: readonly string[];
@@ -17,9 +21,55 @@ export interface IToastOptions {
 }
 export interface IToastResult {
     readonly supported: boolean;
+    /**
+     * True when a live toast with the requested dedupe key is already visible.
+     */
+    readonly suppressed?: boolean;
     readonly clicked: boolean;
     readonly actionIndex?: number;
 }
+/**
+ * A count badge to render on the application icon in the dock (macOS), the
+ * launcher (Linux) or over the taskbar icon of a window (Windows).
+ */
+export interface IApplicationBadge {
+    /** The number to show. A count of `0` clears the badge. */
+    readonly count: number;
+    /** Accessible description of the badge, used for the Windows taskbar overlay. */
+    readonly description: string;
+    /**
+     * PNG image data as a `data:` URL for the Windows taskbar overlay icon,
+     * which has no built-in count rendering. Ignored on other platforms,
+     * where the OS renders {@link count} itself.
+     */
+    readonly iconDataURL?: string;
+}
+/**
+ * A ZIP entry whose contents are inline or streamed from a local file.
+ */
+export type INativeZipFile = {
+    readonly path: string;
+    readonly contents: string;
+} | {
+    readonly path: string;
+    readonly source: URI;
+    readonly size: number;
+    /** Skip this entry when its source cannot be opened or inspected. */
+    readonly skipSourceErrors?: boolean;
+} | {
+    readonly sourceArchive: URI;
+};
+export interface INativeZipOptions {
+    readonly maxSize?: number;
+    readonly maxEntries: number;
+}
+export interface IOpenAgentsWindowOptions {
+    readonly folderUri?: UriComponents;
+    /** Use the invoking editor's folder only for a fresh composer, without replacing an existing session or user choice. */
+    readonly folderUriIsDefault?: boolean;
+    readonly sessionResource?: UriComponents;
+    readonly source?: AgentsWindowOpenSource;
+}
 export interface ICPUProperties {
     model: string;
     speed: number;
@@ -36,6 +86,58 @@ export interface IOSStatistics {
     freemem: number;
     loadavg: number[];
 }
+export interface IOSProxy {
+    readonly kind: "direct" | "http" | "socks";
+    readonly host?: string;
+}
+export interface IOSProxyEnvironmentVariableStatus {
+    readonly variable: string;
+    readonly value: string;
+    readonly error?: string;
+}
+export interface IOSProxyPacSourceStatus {
+    readonly state: "disabled" | "unsupported" | "unconfigured" | "not-found" | "available" | "error-discovery" | "error-download" | "unknown";
+    readonly url?: string;
+    readonly error?: string;
+}
+export interface IOSProxyConfig {
+    readonly environment: {
+        readonly httpProxy?: IOSProxyEnvironmentVariableStatus;
+        readonly httpsProxy?: IOSProxyEnvironmentVariableStatus;
+        readonly allProxy?: IOSProxyEnvironmentVariableStatus;
+        readonly noProxy?: IOSProxyEnvironmentVariableStatus;
+    };
+    readonly autoDetect: boolean;
+    readonly pacUrl?: string;
+    readonly pac?: {
+        readonly url: string;
+        readonly content: string;
+        readonly source: "wpad-dns" | "wpad-dhcp" | "configured" | "unknown";
+    };
+    readonly wpadDhcp: IOSProxyPacSourceStatus;
+    readonly wpadDns: IOSProxyPacSourceStatus;
+    readonly configuredPac: IOSProxyPacSourceStatus;
+    readonly staticRules?: {
+        readonly http?: IOSProxy;
+        readonly https?: IOSProxy;
+        readonly socks?: IOSProxy;
+    };
+    readonly platform?: {
+        readonly kind: "windows";
+        readonly proxy?: string;
+        readonly proxyBypass?: string;
+    } | {
+        readonly kind: "macos";
+        readonly exceptions: readonly string[];
+        readonly excludeSimpleHostnames: boolean;
+    } | {
+        readonly kind: "linux";
+        readonly mode?: string;
+        readonly ignoreHosts: readonly string[];
+    } | {
+        readonly kind: "unknown";
+    };
+}
 export interface INativeHostOptions {
     readonly targetWindowId?: number;
 }
@@ -140,10 +242,7 @@ export interface ICommonNativeHostService {
     getNativeWindowHandle(windowId: number): Promise<VSBuffer | undefined>;
     openWindow(options?: IOpenEmptyWindowOptions): Promise<void>;
     openWindow(toOpen: IWindowOpenable[], options?: IOpenWindowOptions): Promise<void>;
-    openAgentsWindow(options?: {
-        folderUri?: UriComponents;
-        sessionResource?: UriComponents;
-    }): Promise<void>;
+    openAgentsWindow(options?: IOpenAgentsWindowOptions): Promise<void>;
     /**
      * Registers this window's set of system-wide (OS global) keybindings with the main process,
      * replacing any previously registered by this window. The shortcuts fire even when the
@@ -193,6 +292,11 @@ export interface ICommonNativeHostService {
     showItemInFolder(path: string): Promise<void>;
     setRepresentedFilename(path: string, options?: INativeHostOptions): Promise<void>;
     setDocumentEdited(edited: boolean, options?: INativeHostOptions): Promise<void>;
+    /**
+     * Renders a count badge on the application icon. Passing `undefined` or a
+     * badge with a count of `0` clears it again.
+     */
+    setApplicationBadge(badge: IApplicationBadge | undefined, options?: INativeHostOptions): Promise<void>;
     openExternal(url: string, defaultApplication?: string): Promise<boolean>;
     moveItemToTrash(fullPath: string): Promise<void>;
     getMediaAccessStatus(mediaType: "microphone" | "camera" | "screen"): Promise<"not-determined" | "granted" | "denied" | "restricted" | "unknown">;
@@ -252,6 +356,8 @@ export interface ICommonNativeHostService {
     profileRenderer(session: string, duration: number): Promise<IV8Profile>;
     startTracing(categories: string, options?: IStartTracingOptions): Promise<void>;
     resolveProxy(url: string): Promise<string | undefined>;
+    resolveProxyWithPackage(url: string): Promise<IOSProxy[]>;
+    readProxyConfigWithPackage(): Promise<IOSProxyConfig>;
     lookupAuthorization(authInfo: AuthInfo): Promise<Credentials | undefined>;
     lookupKerberosAuthorization(url: string): Promise<string | undefined>;
     loadCertificates(): Promise<string[]>;
@@ -265,12 +371,12 @@ export interface ICommonNativeHostService {
      * Creates a zip file at the specified path containing the provided files.
      *
      * @param zipPath The URI where the zip file should be created.
-     * @param files An array of file entries to include in the zip, each with a relative path and string contents.
+     * @param files An array of file entries to include in the zip. Each entry has
+     * a relative path and is either given inline string `contents`, or a local
+     * file `source` URI together with the number of leading bytes (`size`) to
+     * stream from it.
      */
-    createZipFile(zipPath: URI, files: {
-        path: string;
-        contents: string;
-    }[]): Promise<void>;
+    createZipFile(zipPath: URI, files: INativeZipFile[], options?: INativeZipOptions): Promise<void>;
     getSystemIdleState(idleThreshold: number): Promise<SystemIdleState>;
     getSystemIdleTime(): Promise<number>;
     getCurrentThermalState(): Promise<ThermalState>;

package/vscode/src/vs/platform/networkFilter/common/networkFilterService.service.d.ts

@@ -16,11 +16,15 @@ export interface IAgentNetworkFilterService {
     /**
     * Extracts the domain from a URI and checks it against the configured
     * allowed/denied domain filter.
-    * File URIs and URIs without an authority always pass.
+    * File URIs and unfiltered schemes without an authority always pass.
     * @returns `true` if the URI's domain is allowed, `false` if blocked.
     */
     isUriAllowed(uri: URI): boolean;
     /**
+    * Returns whether network filtering is currently enabled.
+    */
+    isEnabled(): boolean;
+    /**
     * Formats an error message for a blocked URI based on the current filter configuration.
     * @param uri The URI that was blocked.
     * @returns A localized error message explaining that access to the URI is blocked by policy.