@codingame/monaco-vscode-api 32.0.1 → 33.0.3

package/vscode/src/vs/workbench/contrib/inlineCompletions/browser/inlineCompletionLanguageStatusBarContribution.js

@@ -0,0 +1,108 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createHotClass } from '../../../../base/common/hotReloadHelpers.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
+import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController.js';
+import { localize } from '../../../../nls.js';
+import { IChatEntitlementService } from '../../../services/chat/common/chatEntitlementService.service.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { ILanguageStatusService } from '../../../services/languageStatus/common/languageStatusService.service.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
+import { debouncedObservable } from '../../../../base/common/observableInternal/utils/utils.js';
+import { autorunWithStore } from '../../../../base/common/observableInternal/reactions/autorun.js';
+
+let InlineCompletionLanguageStatusBarContribution = class InlineCompletionLanguageStatusBarContribution extends Disposable {
+    static {
+        this.hot = createHotClass(this);
+    }
+    static {
+        this.Id = "vs.contrib.inlineCompletionLanguageStatusBarContribution";
+    }
+    static {
+        this.languageStatusBarDisposables = ( new Set());
+    }
+    constructor(_languageStatusService, _editorService, _chatEntitlementService) {
+        super();
+        this._languageStatusService = _languageStatusService;
+        this._editorService = _editorService;
+        this._chatEntitlementService = _chatEntitlementService;
+        this._activeEditor = observableFromEvent(
+            this,
+            _editorService.onDidActiveEditorChange,
+            () => this._editorService.activeTextEditorControl
+        );
+        this._sentiment = this._chatEntitlementService.sentimentObs;
+        this._state = derived(this, reader => {
+            const editor = this._activeEditor.read(reader);
+            if (!editor || !isCodeEditor(editor)) {
+                return undefined;
+            }
+            const c = InlineCompletionsController.get(editor);
+            const model = c?.model.read(reader);
+            if (!model) {
+                return undefined;
+            }
+            return {
+                model,
+                status: debouncedObservable(model.status, 300)
+            };
+        });
+        this._register(autorunWithStore((reader, store) => {
+            const sentiment = this._sentiment.read(reader);
+            if (sentiment.hidden) {
+                return;
+            }
+            const state = this._state.read(reader);
+            if (!state) {
+                return;
+            }
+            const status = state.status.read(reader);
+            const statusMap = {
+                loading: {
+                    shortLabel: "",
+                    label: ( localize(10598, "Loading...")),
+                    loading: true
+                },
+                ghostText: {
+                    shortLabel: "$(lightbulb)",
+                    label: "$(copilot) " + ( localize(10599, "Inline completion available")),
+                    loading: false
+                },
+                inlineEdit: {
+                    shortLabel: "$(lightbulb-sparkle)",
+                    label: "$(copilot) " + ( localize(10600, "Inline edit available")),
+                    loading: false
+                },
+                noSuggestion: {
+                    shortLabel: "$(circle-slash)",
+                    label: "$(copilot) " + ( localize(10601, "No inline suggestion available")),
+                    loading: false
+                }
+            };
+            store.add(this._languageStatusService.addStatus({
+                accessibilityInfo: undefined,
+                busy: statusMap[status].loading,
+                command: undefined,
+                detail: ( localize(10602, "Inline suggestions")),
+                id: "inlineSuggestions",
+                label: {
+                    value: statusMap[status].label,
+                    shortValue: statusMap[status].shortLabel
+                },
+                name: ( localize(10603, "Inline Suggestions")),
+                selector: {
+                    pattern: state.model.textModel.uri.fsPath
+                },
+                severity: Severity$1.Info,
+                source: "inlineSuggestions"
+            }));
+        }));
+    }
+};
+InlineCompletionLanguageStatusBarContribution = ( __decorate([( __param(0, ILanguageStatusService)), ( __param(1, IEditorService)), ( __param(2, IChatEntitlementService))], InlineCompletionLanguageStatusBarContribution));
+
+export { InlineCompletionLanguageStatusBarContribution };

package/vscode/src/vs/workbench/contrib/inlineCompletions/browser/inlineCompletions.contribution.d.ts

@@ -0,0 +1,8 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { ILanguageFeaturesService } from "../../../../editor/common/services/languageFeatures.service.js";
+import { IWorkbenchContribution } from "../../../common/contributions.js";
+export declare class InlineCompletionSchemaContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _languageFeaturesService;
+    static Id: string;
+    constructor(_languageFeaturesService: ILanguageFeaturesService);
+}

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

@@ -0,0 +1,49 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { withoutDuplicates } from '../../../../base/common/arrays.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
+import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.service.js';
+import { providerIdSchemaUri, inlineCompletionProviderGetMatcher } from '../../../../editor/contrib/inlineCompletions/browser/controller/commands.js';
+import { Extensions } from '../../../../platform/jsonschemas/common/jsonContributionRegistry.js';
+import { wrapInHotClass1 } from '../../../../platform/observable/common/wrapInHotClass.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
+import { InlineCompletionLanguageStatusBarContribution } from './inlineCompletionLanguageStatusBarContribution.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
+
+registerWorkbenchContribution2(
+    InlineCompletionLanguageStatusBarContribution.Id,
+    wrapInHotClass1(InlineCompletionLanguageStatusBarContribution.hot),
+    WorkbenchPhase.Eventually
+);
+let InlineCompletionSchemaContribution = class InlineCompletionSchemaContribution extends Disposable {
+    static {
+        this.Id = "vs.contrib.InlineCompletionSchemaContribution";
+    }
+    constructor(_languageFeaturesService) {
+        super();
+        this._languageFeaturesService = _languageFeaturesService;
+        const registry = ( Registry.as(Extensions.JSONContribution));
+        const inlineCompletionsProvider = observableFromEvent(
+            this,
+            this._languageFeaturesService.inlineCompletionsProvider.onDidChange,
+            () => this._languageFeaturesService.inlineCompletionsProvider.allNoModel()
+        );
+        this._register(autorun(reader => {
+            const provider = inlineCompletionsProvider.read(reader);
+            registry.registerSchema(providerIdSchemaUri, {
+                enum: withoutDuplicates(provider.flatMap(p => inlineCompletionProviderGetMatcher(p)))
+            }, reader.store);
+        }));
+    }
+};
+InlineCompletionSchemaContribution = ( __decorate([( __param(0, ILanguageFeaturesService))], InlineCompletionSchemaContribution));
+registerWorkbenchContribution2(
+    InlineCompletionSchemaContribution.Id,
+    InlineCompletionSchemaContribution,
+    WorkbenchPhase.Eventually
+);
+
+export { InlineCompletionSchemaContribution };

package/vscode/src/vs/workbench/contrib/list/browser/listResizeColumnAction.js

@@ -12,11 +12,11 @@ class ListResizeColumnAction extends Action2 {
         super({
             id: "list.resizeColumn",
             title: {
-                value: ( localize(10613, "Resize Column")),
+                value: ( localize(10740, "Resize Column")),
                 original: "Resize Column"
             },
             category: {
-                value: ( localize(10614, "List")),
+                value: ( localize(10741, "List")),
                 original: "List"
             },
             precondition: WorkbenchListFocusContextKey,

package/vscode/src/vs/workbench/contrib/list/browser/tableColumnResizeQuickPick.js

@@ -21,15 +21,15 @@ let TableColumnResizeQuickPick = class TableColumnResizeQuickPick extends Dispos
             }
         });
         const column = await this._quickInputService.pick(items, {
-            placeHolder: ( localize(10615, "Select the column to resize, type to filter."))
+            placeHolder: ( localize(10742, "Select the column to resize, type to filter."))
         });
         if (!column) {
             return;
         }
         const value = await this._quickInputService.input({
-            placeHolder: ( localize(10616, "i.e. 20, 60, 100...")),
+            placeHolder: ( localize(10743, "i.e. 20, 60, 100...")),
             prompt: ( localize(
-                10617,
+                10744,
                 "Please enter a width in percentage for the '{0}' column.",
                 column.label
             )),
@@ -44,10 +44,10 @@ let TableColumnResizeQuickPick = class TableColumnResizeQuickPick extends Dispos
     async _validateColumnResizeValue(input) {
         const percentage = Number.parseInt(input);
         if (input && !Number.isInteger(percentage)) {
-            return localize(10618, "Please enter an integer.");
+            return localize(10745, "Please enter an integer.");
         } else if (percentage < 0 || percentage > 100) {
             return localize(
-                10619,
+                10746,
                 "Please enter a number greater than 0 and less than or equal to 100."
             );
         }

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpCommandsAddConfiguration.js

@@ -48,31 +48,31 @@ var AddConfigurationType;
 })(AddConfigurationType || (AddConfigurationType = {}));
 const AssistedTypes = {
     [AddConfigurationType.NpmPackage]: {
-        title: ( localize(10911, "Enter NPM Package Name")),
-        placeholder: ( localize(10912, "Package name (e.g., @org/package)")),
-        pickLabel: ( localize(10913, "NPM Package")),
-        pickDescription: ( localize(10914, "Install from an NPM package name")),
+        title: ( localize(11038, "Enter NPM Package Name")),
+        placeholder: ( localize(11039, "Package name (e.g., @org/package)")),
+        pickLabel: ( localize(11040, "NPM Package")),
+        pickDescription: ( localize(11041, "Install from an NPM package name")),
         enabledConfigKey: null
     },
     [AddConfigurationType.PipPackage]: {
-        title: ( localize(10915, "Enter Pip Package Name")),
-        placeholder: ( localize(10916, "Package name (e.g., package-name)")),
-        pickLabel: ( localize(10917, "Pip Package")),
-        pickDescription: ( localize(10918, "Install from a Pip package name")),
+        title: ( localize(11042, "Enter Pip Package Name")),
+        placeholder: ( localize(11043, "Package name (e.g., package-name)")),
+        pickLabel: ( localize(11044, "Pip Package")),
+        pickDescription: ( localize(11045, "Install from a Pip package name")),
         enabledConfigKey: null
     },
     [AddConfigurationType.NuGetPackage]: {
-        title: ( localize(10919, "Enter NuGet Package Name")),
-        placeholder: ( localize(10920, "Package name (e.g., Package.Name)")),
-        pickLabel: ( localize(10921, "NuGet Package")),
-        pickDescription: ( localize(10922, "Install from a NuGet package name")),
+        title: ( localize(11046, "Enter NuGet Package Name")),
+        placeholder: ( localize(11047, "Package name (e.g., Package.Name)")),
+        pickLabel: ( localize(11048, "NuGet Package")),
+        pickDescription: ( localize(11049, "Install from a NuGet package name")),
         enabledConfigKey: "chat.mcp.assisted.nuget.enabled"
     },
     [AddConfigurationType.DockerImage]: {
-        title: ( localize(10923, "Enter Docker Image Name")),
-        placeholder: ( localize(10924, "Image name (e.g., mcp/imagename)")),
-        pickLabel: ( localize(10925, "Docker Image")),
-        pickDescription: ( localize(10926, "Install from a Docker image")),
+        title: ( localize(11050, "Enter Docker Image Name")),
+        placeholder: ( localize(11051, "Image name (e.g., mcp/imagename)")),
+        pickLabel: ( localize(11052, "Docker Image")),
+        pickDescription: ( localize(11053, "Install from a Docker image")),
         enabledConfigKey: null
     }
 };
@@ -119,12 +119,12 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
     async getServerType() {
         const items = [{
             kind: AddConfigurationType.Stdio,
-            label: ( localize(10927, "Command (stdio)")),
-            description: ( localize(10928, "Run a local command that implements the MCP protocol"))
+            label: ( localize(11054, "Command (stdio)")),
+            description: ( localize(11055, "Run a local command that implements the MCP protocol"))
         }, {
             kind: AddConfigurationType.HTTP,
-            label: ( localize(10929, "HTTP (HTTP or Server-Sent Events)")),
-            description: ( localize(10930, "Connect to a remote HTTP server that implements the MCP protocol"))
+            label: ( localize(11056, "HTTP (HTTP or Server-Sent Events)")),
+            description: ( localize(11057, "Connect to a remote HTTP server that implements the MCP protocol"))
         }];
         let aiSupported;
         try {
@@ -133,7 +133,7 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
         if (aiSupported) {
             items.unshift({
                 type: "separator",
-                label: ( localize(10931, "Manual Install"))
+                label: ( localize(11058, "Manual Install"))
             });
             const elligableTypes = ( Object.entries(AssistedTypes).map((
                 [type, {
@@ -156,7 +156,7 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
             })).filter(x => !!x);
             items.push({
                 type: "separator",
-                label: ( localize(10932, "Model-Assisted"))
+                label: ( localize(11059, "Model-Assisted"))
             }, ...elligableTypes);
         }
         items.push({
@@ -166,15 +166,15 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
         if (discovery && typeof discovery === "object" && ( allDiscoverySources.some(d => !discovery[d]))) {
             items.push({
                 kind: "discovery",
-                label: ( localize(10933, "Add from another application..."))
+                label: ( localize(11060, "Add from another application..."))
             });
         }
         items.push({
             kind: "browse",
-            label: ( localize(10934, "Browse MCP Servers..."))
+            label: ( localize(11061, "Browse MCP Servers..."))
         });
         const result = await this._quickInputService.pick(items, {
-            placeHolder: ( localize(10935, "Choose the type of MCP server to add"))
+            placeHolder: ( localize(11062, "Choose the type of MCP server to add"))
         });
         if (result?.kind === "browse") {
             this._commandService.executeCommand(McpCommandIds.Browse);
@@ -188,8 +188,8 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
     }
     async getStdioConfig() {
         const command = await this._quickInputService.input({
-            title: ( localize(10936, "Enter Command")),
-            placeHolder: ( localize(10937, "Command to run (with optional arguments)")),
+            title: ( localize(11063, "Enter Command")),
+            placeHolder: ( localize(11064, "Command to run (with optional arguments)")),
             ignoreFocusLost: true
         });
         if (!command) {
@@ -207,8 +207,8 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
     }
     async getSSEConfig() {
         const url = await this._quickInputService.input({
-            title: ( localize(10938, "Enter Server URL")),
-            placeHolder: ( localize(10939, "URL of the MCP server (e.g., http://localhost:3000)")),
+            title: ( localize(11065, "Enter Server URL")),
+            placeHolder: ( localize(11066, "URL of the MCP server (e.g., http://localhost:3000)")),
             ignoreFocusLost: true
         });
         if (!url) {
@@ -224,8 +224,8 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
     }
     async getServerId(suggestion = `my-mcp-server-${generateUuid().split("-")[0]}`) {
         const id = await this._quickInputService.input({
-            title: ( localize(10940, "Enter Server ID")),
-            placeHolder: ( localize(10941, "Unique identifier for this server")),
+            title: ( localize(11067, "Enter Server ID")),
+            placeHolder: ( localize(11068, "Unique identifier for this server")),
             value: suggestion,
             ignoreFocusLost: true
         });
@@ -234,15 +234,15 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
     async getConfigurationTarget() {
         const options = [{
             target: ConfigurationTarget.USER_LOCAL,
-            label: ( localize(10942, "Global")),
-            description: ( localize(10943, "Available in all workspaces, runs locally"))
+            label: ( localize(11069, "Global")),
+            description: ( localize(11070, "Available in all workspaces, runs locally"))
         }];
         const raLabel = this._environmentService.remoteAuthority && this._label.getHostLabel(Schemas.vscodeRemote, this._environmentService.remoteAuthority);
         if (raLabel) {
             options.push({
                 target: ConfigurationTarget.USER_REMOTE,
-                label: ( localize(10944, "Remote")),
-                description: ( localize(10945, "Available on this remote machine, runs on {0}", raLabel))
+                label: ( localize(11071, "Remote")),
+                description: ( localize(11072, "Available on this remote machine, runs on {0}", raLabel))
             });
         }
         const workbenchState = this._workspaceService.getWorkbenchState();
@@ -251,14 +251,14 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
             if (this._environmentService.remoteAuthority) {
                 options.push({
                     target,
-                    label: ( localize(10946, "Workspace")),
-                    description: ( localize(10947, "Available in this workspace, runs on {0}", raLabel))
+                    label: ( localize(11073, "Workspace")),
+                    description: ( localize(11074, "Available in this workspace, runs on {0}", raLabel))
                 });
             } else {
                 options.push({
                     target,
-                    label: ( localize(10946, "Workspace")),
-                    description: ( localize(10948, "Available in this workspace, runs locally"))
+                    label: ( localize(11073, "Workspace")),
+                    description: ( localize(11075, "Available in this workspace, runs locally"))
                 });
             }
         }
@@ -266,8 +266,8 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
             return options[0].target;
         }
         const targetPick = await this._quickInputService.pick(options, {
-            title: ( localize(10949, "Add MCP Server")),
-            placeHolder: ( localize(10950, "Select the configuration target"))
+            title: ( localize(11076, "Add MCP Server")),
+            placeHolder: ( localize(11077, "Select the configuration target"))
         });
         return targetPick?.target;
     }
@@ -289,7 +289,7 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
         })(LoadAction || (LoadAction = {}));
         const loadingQuickPickStore = ( new DisposableStore());
         const loadingQuickPick = loadingQuickPickStore.add(this._quickInputService.createQuickPick());
-        loadingQuickPick.title = ( localize(10951, "Loading package details..."));
+        loadingQuickPick.title = ( localize(11078, "Loading package details..."));
         loadingQuickPick.busy = true;
         loadingQuickPick.ignoreFocusOut = true;
         const packageType = this.getPackageType(type);
@@ -317,21 +317,21 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
                 if (result?.helpUri) {
                     items.push({
                         id: LoadAction.OpenUri,
-                        label: result.helpUriLabel ?? ( localize(10952, "Open help URL")),
+                        label: result.helpUriLabel ?? ( localize(11079, "Open help URL")),
                         helpUri: ( URI.parse(result.helpUri))
                     });
                 }
                 items.push({
                     id: LoadAction.Retry,
-                    label: ( localize(10953, "Try a different package"))
+                    label: ( localize(11080, "Try a different package"))
                 }, {
                     id: LoadAction.Cancel,
-                    label: ( localize(10954, "Cancel"))
+                    label: ( localize(11081, "Cancel"))
                 });
                 loadingQuickPick.items = items;
             } else {
                 loadingQuickPick.title = ( localize(
-                    10955,
+                    11082,
                     "Install {0}{1} from {2}?",
                     result.name ?? packageName,
                     result.version ? `@${result.version}` : "",
@@ -339,10 +339,10 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
                 ));
                 loadingQuickPick.items = [{
                     id: LoadAction.Allow,
-                    label: ( localize(10956, "Allow"))
+                    label: ( localize(11083, "Allow"))
                 }, {
                     id: LoadAction.Cancel,
-                    label: ( localize(10954, "Cancel"))
+                    label: ( localize(11081, "Cancel"))
                 }];
             }
             loadingQuickPick.busy = false;
@@ -497,19 +497,19 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
     }
     async pickForUrlHandler(resource, showIsPrimary = false) {
         const name = decodeURIComponent(basename(resource)).replace(/\.json$/, "");
-        const placeHolder = ( localize(10957, "Install MCP server {0}", name));
+        const placeHolder = ( localize(11084, "Install MCP server {0}", name));
         const items = [{
             id: "install",
-            label: ( localize(10958, "Install Server"))
+            label: ( localize(11085, "Install Server"))
         }, {
             id: "show",
-            label: ( localize(10959, "Show Configuration", name))
+            label: ( localize(11086, "Show Configuration", name))
         }, {
             id: "rename",
-            label: ( localize(10960, "Rename \"{0}\"", name))
+            label: ( localize(11087, "Rename \"{0}\"", name))
         }, {
             id: "cancel",
-            label: ( localize(10954, "Cancel"))
+            label: ( localize(11081, "Cancel"))
         }];
         if (showIsPrimary) {
             [items[0], items[1]] = [items[1], items[0]];
@@ -541,7 +541,7 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
                 this._editorService.closeEditors(getEditors());
                 this.showOnceDiscovered(name);
             } catch (e) {
-                this._notificationService.error(( localize(10961, "Error installing MCP server {0}: {1}", name, e.message)));
+                this._notificationService.error(( localize(11088, "Error installing MCP server {0}: {1}", name, e.message)));
                 await this._editorService.openEditor({
                     resource
                 });
@@ -550,7 +550,7 @@ let McpAddConfigurationCommand = class McpAddConfigurationCommand {
         case "rename":
             {
                 const newName = await this._quickInputService.input({
-                    placeHolder: ( localize(10962, "Enter new name")),
+                    placeHolder: ( localize(11089, "Enter new name")),
                     value: name
                 });
                 if (newName) {
@@ -603,14 +603,14 @@ let McpInstallFromManifestCommand = class McpInstallFromManifestCommand {
     }
     async run() {
         const result = await this._fileDialogService.showOpenDialog({
-            title: ( localize(10963, "Select MCP Server Manifest")),
+            title: ( localize(11090, "Select MCP Server Manifest")),
             filters: [{
-                name: ( localize(10964, "MCP Manifest")),
+                name: ( localize(11091, "MCP Manifest")),
                 extensions: ["json"]
             }],
             canSelectFiles: true,
             canSelectMany: false,
-            openLabel: mnemonicButtonLabel(( localize(10965, "&&Install")))
+            openLabel: mnemonicButtonLabel(( localize(11092, "&&Install")))
         });
         if (!result?.[0]) {
             return;
@@ -621,11 +621,11 @@ let McpInstallFromManifestCommand = class McpInstallFromManifestCommand {
             const contents = await this._fileService.readFile(manifestUri);
             manifest = parse(( contents.value.toString()));
         } catch (e) {
-            this._notificationService.error(( localize(10966, "Failed to read manifest file: {0}", e.message)));
+            this._notificationService.error(( localize(11093, "Failed to read manifest file: {0}", e.message)));
             return;
         }
         if (!manifest || typeof manifest !== "object") {
-            this._notificationService.error(( localize(10967, "Invalid manifest file: expected a JSON object")));
+            this._notificationService.error(( localize(11094, "Invalid manifest file: expected a JSON object")));
             return;
         }
         const galleryManifest = manifest;
@@ -636,7 +636,7 @@ let McpInstallFromManifestCommand = class McpInstallFromManifestCommand {
             packageType = RegistryType.REMOTE;
         } else {
             this._notificationService.error(( localize(
-                10968,
+                11095,
                 "Invalid manifest: expected 'packages' or 'remotes' with at least one entry"
             )));
             return;
@@ -657,14 +657,14 @@ let McpInstallFromManifestCommand = class McpInstallFromManifestCommand {
                 );
             }
         } catch (e) {
-            this._notificationService.error(( localize(10969, "Failed to parse manifest: {0}", e.message)));
+            this._notificationService.error(( localize(11096, "Failed to parse manifest: {0}", e.message)));
             return;
         }
         let name = galleryManifest.name;
         if (!name) {
             name = await this._quickInputService.input({
-                title: ( localize(10970, "Enter Server ID")),
-                placeHolder: ( localize(10971, "Unique identifier for this server")),
+                title: ( localize(11097, "Enter Server ID")),
+                placeHolder: ( localize(11098, "Unique identifier for this server")),
                 value: basename(manifestUri).replace(/\.json$/i, ""),
                 ignoreFocusLost: true
             });
@@ -678,9 +678,9 @@ let McpInstallFromManifestCommand = class McpInstallFromManifestCommand {
                 config,
                 inputs
             });
-            this._notificationService.info(( localize(10972, "MCP server '{0}' installed successfully", name)));
+            this._notificationService.info(( localize(11099, "MCP server '{0}' installed successfully", name)));
         } catch (e) {
-            this._notificationService.error(( localize(10973, "Failed to install MCP server: {0}", e.message)));
+            this._notificationService.error(( localize(11100, "Failed to install MCP server: {0}", e.message)));
         }
     }
 };