@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/platform/list/browser/listService.js

@@ -978,8 +978,8 @@ function workbenchTreeDataPreamble(accessor, options) {
             expandOnlyOnTwistieClick: options.expandOnlyOnTwistieClick ?? (configurationService.getValue(treeExpandMode) === "doubleClick"),
             contextViewProvider: contextViewService,
             findWidgetStyles: defaultFindWidgetStyles,
-            enableStickyScroll: Boolean(configurationService.getValue(treeStickyScroll)),
-            stickyScrollMaxItemCount: Number(configurationService.getValue(treeStickyScrollMaxElements))
+            enableStickyScroll: options.enableStickyScroll ?? Boolean(configurationService.getValue(treeStickyScroll)),
+            stickyScrollMaxItemCount: options.stickyScrollMaxItemCount ?? Number(configurationService.getValue(treeStickyScrollMaxElements))
         }
     };
 }
@@ -1120,14 +1120,14 @@ let WorkbenchTreeInternals = class WorkbenchTreeInternals {
                         expandOnlyOnTwistieClick: configurationService.getValue(treeExpandMode) === "doubleClick"
                     };
                 }
-                if (e.affectsConfiguration(treeStickyScroll)) {
+                if (e.affectsConfiguration(treeStickyScroll) && options.enableStickyScroll === undefined) {
                     const enableStickyScroll = configurationService.getValue(treeStickyScroll);
                     newOptions = {
                         ...newOptions,
                         enableStickyScroll
                     };
                 }
-                if (e.affectsConfiguration(treeStickyScrollMaxElements)) {
+                if (e.affectsConfiguration(treeStickyScrollMaxElements) && options.stickyScrollMaxItemCount === undefined) {
                     const stickyScrollMaxItemCount = Math.max(1, configurationService.getValue(treeStickyScrollMaxElements));
                     newOptions = {
                         ...newOptions,
@@ -1186,16 +1186,16 @@ const configurationRegistry = ( Registry.as(Extensions.Configuration));
 configurationRegistry.registerConfiguration({
     id: "workbench",
     order: 7,
-    title: ( localize(2139, "Workbench")),
+    title: ( localize(2311, "Workbench")),
     type: "object",
     properties: {
         [multiSelectModifierSettingKey]: {
             type: "string",
             enum: ["ctrlCmd", "alt"],
-            markdownEnumDescriptions: [( localize(2140, "Maps to `Control` on Windows and Linux and to `Command` on macOS.")), ( localize(2141, "Maps to `Alt` on Windows and Linux and to `Option` on macOS."))],
+            markdownEnumDescriptions: [( localize(2312, "Maps to `Control` on Windows and Linux and to `Command` on macOS.")), ( localize(2313, "Maps to `Alt` on Windows and Linux and to `Option` on macOS."))],
             default: "ctrlCmd",
             description: ( localize(
-                2142,
+                2314,
                 "The modifier to be used to add an item in trees and lists to a multi-selection with the mouse (for example in the explorer, open editors and scm view). The 'Open to Side' mouse gestures - if supported - will adapt such that they do not conflict with the multiselect modifier."
             ))
         },
@@ -1204,7 +1204,7 @@ configurationRegistry.registerConfiguration({
             enum: ["singleClick", "doubleClick"],
             default: "singleClick",
             description: ( localize(
-                2143,
+                2315,
                 "Controls how to open items in trees and lists using the mouse (if supported). Note that some trees and lists might choose to ignore this setting if it is not applicable."
             ))
         },
@@ -1212,56 +1212,56 @@ configurationRegistry.registerConfiguration({
             type: "boolean",
             default: false,
             description: ( localize(
-                2144,
+                2316,
                 "Controls whether lists and trees support horizontal scrolling in the workbench. Warning: turning on this setting has a performance implication."
             ))
         },
         [scrollByPageKey]: {
             type: "boolean",
             default: false,
-            description: ( localize(2145, "Controls whether clicks in the scrollbar scroll page by page."))
+            description: ( localize(2317, "Controls whether clicks in the scrollbar scroll page by page."))
         },
         [treeIndentKey]: {
             type: "number",
             default: 8,
             minimum: 4,
             maximum: 40,
-            description: ( localize(2146, "Controls tree indentation in pixels."))
+            description: ( localize(2318, "Controls tree indentation in pixels."))
         },
         [treeRenderIndentGuidesKey]: {
             type: "string",
             enum: ["none", "onHover", "always"],
             default: "onHover",
-            description: ( localize(2147, "Controls whether the tree should render indent guides."))
+            description: ( localize(2319, "Controls whether the tree should render indent guides."))
         },
         [listSmoothScrolling]: {
             type: "boolean",
             default: false,
-            description: ( localize(2148, "Controls whether lists and trees have smooth scrolling."))
+            description: ( localize(2320, "Controls whether lists and trees have smooth scrolling."))
         },
         [mouseWheelScrollSensitivityKey]: {
             type: "number",
             default: 1,
             markdownDescription: ( localize(
-                2149,
+                2321,
                 "A multiplier to be used on the `deltaX` and `deltaY` of mouse wheel scroll events."
             ))
         },
         [fastScrollSensitivityKey]: {
             type: "number",
             default: 5,
-            markdownDescription: ( localize(2150, "Scrolling speed multiplier when pressing `Alt`."))
+            markdownDescription: ( localize(2322, "Scrolling speed multiplier when pressing `Alt`."))
         },
         [defaultFindModeSettingKey]: {
             type: "string",
             enum: ["highlight", "filter"],
             enumDescriptions: [( localize(
-                2151,
+                2323,
                 "Highlight elements when searching. Further up and down navigation will traverse only the highlighted elements."
-            )), ( localize(2152, "Filter elements when searching."))],
+            )), ( localize(2324, "Filter elements when searching."))],
             default: "highlight",
             description: ( localize(
-                2153,
+                2325,
                 "Controls the default find mode for lists and trees in the workbench."
             ))
         },
@@ -1269,33 +1269,33 @@ configurationRegistry.registerConfiguration({
             type: "string",
             enum: ["simple", "highlight", "filter"],
             enumDescriptions: [( localize(
-                2154,
+                2326,
                 "Simple keyboard navigation focuses elements which match the keyboard input. Matching is done only on prefixes."
             )), ( localize(
-                2155,
+                2327,
                 "Highlight keyboard navigation highlights elements which match the keyboard input. Further up and down navigation will traverse only the highlighted elements."
             )), ( localize(
-                2156,
+                2328,
                 "Filter keyboard navigation will filter out and hide all the elements which do not match the keyboard input."
             ))],
             default: "highlight",
             description: ( localize(
-                2157,
+                2329,
                 "Controls the keyboard navigation style for lists and trees in the workbench. Can be simple, highlight and filter."
             )),
             deprecated: true,
             deprecationMessage: ( localize(
-                2158,
+                2330,
                 "Please use 'workbench.list.defaultFindMode' and\t'workbench.list.typeNavigationMode' instead."
             ))
         },
         [defaultFindMatchTypeSettingKey]: {
             type: "string",
             enum: ["fuzzy", "contiguous"],
-            enumDescriptions: [( localize(2159, "Use fuzzy matching when searching.")), ( localize(2160, "Use contiguous matching when searching."))],
+            enumDescriptions: [( localize(2331, "Use fuzzy matching when searching.")), ( localize(2332, "Use contiguous matching when searching."))],
             default: "fuzzy",
             description: ( localize(
-                2161,
+                2333,
                 "Controls the type of matching used when searching lists and trees in the workbench."
             ))
         },
@@ -1304,21 +1304,21 @@ configurationRegistry.registerConfiguration({
             enum: ["singleClick", "doubleClick"],
             default: "singleClick",
             description: ( localize(
-                2162,
+                2334,
                 "Controls how tree folders are expanded when clicking the folder names. Note that some trees and lists might choose to ignore this setting if it is not applicable."
             ))
         },
         [treeStickyScroll]: {
             type: "boolean",
             default: true,
-            description: ( localize(2163, "Controls whether sticky scrolling is enabled in trees."))
+            description: ( localize(2335, "Controls whether sticky scrolling is enabled in trees."))
         },
         [treeStickyScrollMaxElements]: {
             type: "number",
             minimum: 1,
             default: 7,
             markdownDescription: ( localize(
-                2164,
+                2336,
                 "Controls the number of sticky elements displayed in the tree when {0} is enabled.",
                 "`#workbench.tree.enableStickyScroll#`"
             ))
@@ -1328,7 +1328,7 @@ configurationRegistry.registerConfiguration({
             enum: ["automatic", "trigger"],
             default: "automatic",
             markdownDescription: ( localize(
-                2165,
+                2337,
                 "Controls how type navigation works in lists and trees in the workbench. When set to `trigger`, type navigation begins once the `list.triggerTypeNavigation` command is run."
             ))
         }

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

@@ -0,0 +1,53 @@
+/** IPC channel name used to reach the transcription service in the utility process. */
+export declare const localTranscriptionChannelName = "localTranscription";
+/** Default on-device model used for dictation. */
+export declare const DEFAULT_LOCAL_TRANSCRIPTION_MODEL = "nemotron-3.5-asr-streaming-0.6b";
+export interface ILocalTranscriptionModelImportResult {
+    readonly model: string;
+    readonly version: number;
+}
+/** Lifecycle of the downloaded transcription model. */
+export declare enum LocalTranscriptionModelState {
+    /** Model has not been requested yet. */
+    Idle = "idle",
+    /** Model files are being downloaded to the on-disk cache. */
+    Downloading = "downloading",
+    /** Model is being loaded into memory. */
+    Loading = "loading",
+    /** Model is loaded and ready to transcribe. */
+    Ready = "ready",
+    /** Model failed to download or load. */
+    Error = "error"
+}
+export interface ILocalTranscriptionModelStatus {
+    readonly state: LocalTranscriptionModelState;
+    /** Overall download progress in [0, 1] while `Downloading`. */
+    readonly progress?: number;
+    /**
+     * Whether model files were actually fetched from the network (a cache miss)
+     * during this preparation, as opposed to loaded from the on-disk cache. Set
+     * on the `Ready` status. Used for download telemetry.
+     */
+    readonly downloaded?: boolean;
+    /** Human-readable error message when `state === Error` (for UI/logging). */
+    readonly error?: string;
+    /**
+     * Allowlisted, low-cardinality error identifier when `state === Error`
+     * (e.g. `network`, `notFound`, `memory`), safe to send as telemetry.
+     */
+    readonly errorCode?: string;
+}
+export interface ILocalTranscriptionResult {
+    /** Cumulative transcript for the active session. */
+    readonly text: string;
+    /** True for the final result emitted after `stop`. */
+    readonly isFinal: boolean;
+    /**
+     * The leading portion of `text` that Foundry has already finalized (its
+     * endpointed segments). The remainder of `text` is the still-in-progress
+     * interim tail. Lets the renderer stop shimmering finalized text as soon as
+     * a segment is endpointed — including the last one during a trailing silence
+     * — instead of waiting for a later interim to confirm it stopped changing.
+     */
+    readonly finalizedText?: string;
+}

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

@@ -0,0 +1,13 @@
+
+
+const DEFAULT_LOCAL_TRANSCRIPTION_MODEL = 'nemotron-3.5-asr-streaming-0.6b';
+var LocalTranscriptionModelState;
+(function (LocalTranscriptionModelState) {
+    LocalTranscriptionModelState["Idle"] = "idle";
+    LocalTranscriptionModelState["Downloading"] = "downloading";
+    LocalTranscriptionModelState["Loading"] = "loading";
+    LocalTranscriptionModelState["Ready"] = "ready";
+    LocalTranscriptionModelState["Error"] = "error";
+})(LocalTranscriptionModelState || (LocalTranscriptionModelState = {}));
+
+export { DEFAULT_LOCAL_TRANSCRIPTION_MODEL, LocalTranscriptionModelState };

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

@@ -0,0 +1,84 @@
+import { VSBuffer } from "../../../base/common/buffer.js";
+import { Event } from "../../../base/common/event.js";
+import { ILocalTranscriptionModelStatus, ILocalTranscriptionResult, ILocalTranscriptionModelImportResult } from "./localTranscription.js";
+export declare const ILocalTranscriptionService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ILocalTranscriptionService>;
+/**
+* On-device speech-to-text using a downloaded model. Transcription runs through
+* Microsoft's Foundry Local streaming ASR engine (onnxruntime + onnxruntime-genai
+* native runtime), which handles decoding, VAD and endpointing internally. The
+* default model is NVIDIA's multilingual Nemotron 3.5 streaming RNN-T. The model
+* is chosen by the `dictation.model` setting. Runs in a utility process. A
+* single transcription session is active at a time (dictation is a singleton
+* in the renderer).
+*
+* The renderer streams PCM16 mono 16 kHz audio via `pushAudio`; the service
+* emits interim transcripts on `onDidTranscribe` and a final one after `stop`.
+*/
+export interface ILocalTranscriptionService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Whether on-device transcription can run in this environment. False on web
+    * (no utility process) and on desktop platforms/architectures without a
+    * Foundry Local native runtime. When false, dictation is unavailable — there
+    * is no cloud fallback.
+    */
+    readonly isSupported: boolean;
+    /** Fires as the model downloads/loads so the UI can show progress. */
+    readonly onDidChangeModelStatus: Event<ILocalTranscriptionModelStatus>;
+    /** Fires with interim (and, after stop, final) transcripts. */
+    readonly onDidTranscribe: Event<ILocalTranscriptionResult>;
+    /** Current model status (e.g. to gate the dictation UI). */
+    getModelStatus(): Promise<ILocalTranscriptionModelStatus>;
+    /**
+    * Imports the default on-device model from an official Foundry Local expansion
+    * pack or a prepared model directory into `cacheDir`.
+    */
+    importModel(options: {
+        readonly sourcePath: string;
+        readonly cacheDir: string;
+    }): Promise<ILocalTranscriptionModelImportResult>;
+    /**
+    * Ensure the model is downloaded/loaded (idempotent) and begin a new
+    * transcription session. `cacheDir` is where model files are stored. `model`
+    * selects the on-device Foundry Local model; when omitted the service default
+    * is used. `language` optionally hints the spoken language.
+    *
+    * `proxyUrl`/`noProxy` bridge VS Code's `http.proxy`/`http.noProxy` settings
+    * into this utility process: when set, they are applied as the standard proxy
+    * environment variables before any download, so all provisioning legs — the
+    * addon tarball and NuGet core libraries (our own fetches) and the native
+    * Foundry Local *model* download — route through the proxy. When they are
+    * omitted, the process's inherited OS environment proxy vars still apply.
+    *
+    * `proxyStrictSSL === false` (VS Code's `http.proxyStrictSSL`) disables TLS
+    * certificate verification for the JavaScript download legs. `proxyAuthorization`
+    * (VS Code's `http.proxyAuthorization`, a `Basic <base64>` value) is folded into
+    * the proxy URL's credentials so both our fetches and the native model download
+    * authenticate to the proxy. TLS-intercepting proxies otherwise rely on the CA
+    * being in the OS trust store (matching `@vscode/proxy-agent` and the desktop
+    * app).
+    *
+    * `runtimeUrlTemplate`/`runtimeVersion` come from `product.dictationRuntime`
+    * (stamped by `build/dictation-runtime/produce.ts`). When set, the native
+    * runtime (Foundry Local addon + core libraries) is downloaded from VS Code's
+    * CDN for this host's target. When omitted (local dev builds), the runtime
+    * falls back to the SDK's own `node_modules` payload and nothing is downloaded.
+    */
+    start(options: {
+        readonly cacheDir: string;
+        readonly model?: string;
+        readonly language?: string;
+        readonly proxyUrl?: string;
+        readonly noProxy?: string;
+        readonly proxyStrictSSL?: boolean;
+        readonly proxyAuthorization?: string;
+        readonly runtimeUrlTemplate?: string;
+        readonly runtimeVersion?: string;
+    }): Promise<void>;
+    /** Append captured audio (raw little-endian PCM16 mono 16 kHz). */
+    pushAudio(chunk: VSBuffer): Promise<void>;
+    /** Finish the session; resolves with the final transcript. */
+    stop(): Promise<string>;
+    /** Abort the session, discarding the transcript. */
+    cancel(): Promise<void>;
+}

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(2338, "Trace"))
         };
     case LogLevel.Debug:
         return {
             original: "Debug",
-            value: ( localize(2167, "Debug"))
+            value: ( localize(2339, "Debug"))
         };
     case LogLevel.Info:
         return {
             original: "Info",
-            value: ( localize(2168, "Info"))
+            value: ( localize(2340, "Info"))
         };
     case LogLevel.Warning:
         return {
             original: "Warning",
-            value: ( localize(2169, "Warning"))
+            value: ( localize(2341, "Warning"))
         };
     case LogLevel.Error:
         return {
             original: "Error",
-            value: ( localize(2170, "Error"))
+            value: ( localize(2342, "Error"))
         };
     case LogLevel.Off:
         return {
             original: "Off",
-            value: ( localize(2171, "Off"))
+            value: ( localize(2343, "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(2344, "Problems are paused because: \"{0}\"", reasons[0])) : ( localize(
+            2345,
             "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(2346, "Error"));
+    _displayStrings[MarkerSeverity.Warning] = ( localize(2347, "Warning"));
+    _displayStrings[MarkerSeverity.Info] = ( localize(2348, "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(2349, "Errors"));
+    _displayStringsPlural[MarkerSeverity.Warning] = ( localize(2350, "Warnings"));
+    _displayStringsPlural[MarkerSeverity.Info] = ( localize(2351, "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>;