@codingame/monaco-vscode-api 15.0.3 → 16.0.0

package/vscode/src/vs/workbench/contrib/format/browser/formatActionsMultiple.js

@@ -10,7 +10,6 @@ import { CancellationTokenSource, CancellationToken } from '../../../../base/com
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { FormattingConflicts, FormattingKind, FormattingMode, getRealAndSyntheticDocumentFormattersOrdered, formatDocumentWithProvider, formatDocumentRangesWithProvider } from '../../../../editor/contrib/format/browser/format.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
 import { Extensions as Extensions$1 } from '../../../../platform/configuration/common/configurationRegistry.js';
@@ -81,8 +80,8 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         DefaultFormatter_1.extensionItemLabels.length = 0;
         DefaultFormatter_1.extensionDescriptions.length = 0;
         DefaultFormatter_1.extensionIds.push(null);
-        DefaultFormatter_1.extensionItemLabels.push(( localize(6977, 'None')));
-        DefaultFormatter_1.extensionDescriptions.push(( localize(6978, "None")));
+        DefaultFormatter_1.extensionItemLabels.push(( localize(7123, 'None')));
+        DefaultFormatter_1.extensionDescriptions.push(( localize(7124, "None")));
         for (const extension of extensions) {
             if (extension.main || extension.browser) {
                 DefaultFormatter_1.extensionIds.push(extension.identifier.value);
@@ -109,13 +108,13 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
                 const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
                 const detail = kind === FormattingKind.File
                     ? ( localize(
-                    6979,
+                    7125,
                     "Extension '{0}' is configured as formatter but it cannot format '{1}'-files",
                     extension.displayName || extension.name,
                     langName
                 ))
                     : ( localize(
-                    6980,
+                    7126,
                     "Extension '{0}' is configured as formatter but it can only format '{1}'-files as a whole, not selections or parts of it.",
                     extension.displayName || extension.name,
                     langName
@@ -129,12 +128,12 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
         const message = !defaultFormatterId
             ? ( localize(
-            6981,
+            7127,
             "There are multiple formatters for '{0}' files. One of them should be configured as default formatter.",
             DefaultFormatter_1._maybeQuotes(langName)
         ))
             : ( localize(
-            6982,
+            7128,
             "Extension '{0}' is configured as formatter but not available. Select a different default formatter to continue.",
             defaultFormatterId
         ));
@@ -147,16 +146,16 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         }
         if (mode !== FormattingMode.Silent) {
             const { confirmed } = await this._dialogService.confirm({
-                message: ( localize(6983, "Configure Default Formatter")),
+                message: ( localize(7129, "Configure Default Formatter")),
                 detail: formatterOrMessage,
-                primaryButton: ( localize(6984, "&&Configure..."))
+                primaryButton: ( localize(7130, "&&Configure..."))
             });
             if (confirmed) {
                 return this._pickAndPersistDefaultFormatter(formatter, document);
             }
         }
         else {
-            this._notificationService.prompt(Severity$1.Info, formatterOrMessage, [{ label: ( localize(6985, "Configure...")), run: () => this._pickAndPersistDefaultFormatter(formatter, document) }], { priority: NotificationPriority.SILENT });
+            this._notificationService.prompt(Severity$1.Info, formatterOrMessage, [{ label: ( localize(7131, "Configure...")), run: () => this._pickAndPersistDefaultFormatter(formatter, document) }], { priority: NotificationPriority.SILENT });
         }
         return undefined;
     }
@@ -170,7 +169,7 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         }));
         const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
         const pick = await this._quickInputService.pick(picks, { placeHolder: ( localize(
-            6986,
+            7132,
             "Select a default formatter for '{0}' files",
             DefaultFormatter_1._maybeQuotes(langName)
         )) });
@@ -203,14 +202,14 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
             if (typeof result !== 'string') {
                 return;
             }
-            const command = { id: `formatter/configure/dfl/${generateUuid()}`, title: ( localize(6987, "Configure...")) };
+            const command = { id: `formatter/configure/dfl/${generateUuid()}`, title: ( localize(7133, "Configure...")) };
             this._languageStatusStore.add(CommandsRegistry.registerCommand(command.id, () => this._pickAndPersistDefaultFormatter(formatter, document)));
             this._languageStatusStore.add(this._languageStatusService.addStatus({
                 id: 'formatter.conflict',
-                name: ( localize(6988, "Formatter Conflicts")),
+                name: ( localize(7134, "Formatter Conflicts")),
                 selector: { language: document.getLanguageId(), pattern: document.uri.fsPath },
                 severity: Severity$1.Error,
-                label: ( localize(6989, "Formatting")),
+                label: ( localize(7135, "Formatting")),
                 detail: result,
                 busy: false,
                 source: '',
@@ -238,7 +237,7 @@ DefaultFormatter = DefaultFormatter_1 = ( __decorate([
     properties: {
         [DefaultFormatter.configName]: {
             description: ( localize(
-                6990,
+                7136,
                 "Defines a default formatter which takes precedence over all other formatter settings. Must be the identifier of an extension contributing a formatter."
             )),
             type: ['string', 'null'],
@@ -249,16 +248,6 @@ DefaultFormatter = DefaultFormatter_1 = ( __decorate([
         }
     }
 });
-function logFormatterTelemetry(telemetryService, mode, options, pick) {
-    function extKey(obj) {
-        return obj.extensionId ? ExtensionIdentifier.toKey(obj.extensionId) : 'unknown';
-    }
-    telemetryService.publicLog2('formatterpick', {
-        mode,
-        extensions: ( options.map(extKey)),
-        pick: pick ? extKey(pick) : 'none'
-    });
-}
 async function showFormatterPick(accessor, model, formatters) {
     const quickPickService = accessor.get(IQuickInputService);
     const configService = accessor.get(IConfigurationService);
@@ -271,7 +260,7 @@ async function showFormatterPick(accessor, model, formatters) {
         const pick = {
             index,
             label: provider.displayName || '',
-            description: isDefault ? ( localize(6991, "(default)")) : undefined,
+            description: isDefault ? ( localize(7137, "(default)")) : undefined,
         };
         if (isDefault) {
             defaultFormatterPick = pick;
@@ -279,10 +268,10 @@ async function showFormatterPick(accessor, model, formatters) {
         return pick;
     }));
     const configurePick = {
-        label: ( localize(6992, "Configure Default Formatter..."))
+        label: ( localize(7138, "Configure Default Formatter..."))
     };
     const pick = await quickPickService.pick([...picks, { type: 'separator' }, configurePick], {
-        placeHolder: ( localize(6993, "Select a formatter")),
+        placeHolder: ( localize(7139, "Select a formatter")),
         activeItem: defaultFormatterPick
     });
     if (!pick) {
@@ -291,7 +280,7 @@ async function showFormatterPick(accessor, model, formatters) {
     else if (pick === configurePick) {
         const langName = languageService.getLanguageName(model.getLanguageId()) || model.getLanguageId();
         const pick = await quickPickService.pick(picks, { placeHolder: ( localize(
-            6986,
+            7132,
             "Select a default formatter for '{0}' files",
             DefaultFormatter._maybeQuotes(langName)
         )) });
@@ -308,7 +297,7 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatDocument.multiple',
-            label: ( localize(6994, "Format Document With...")),
+            label: ( localize(7140, "Format Document With...")),
             alias: 'Format Document...',
             precondition: ( ContextKeyExpr.and(
                 EditorContextKeys.writable,
@@ -325,7 +314,6 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
             return;
         }
         const instaService = accessor.get(IInstantiationService);
-        const telemetryService = accessor.get(ITelemetryService);
         const languageFeaturesService = accessor.get(ILanguageFeaturesService);
         const model = editor.getModel();
         const provider = getRealAndSyntheticDocumentFormattersOrdered(languageFeaturesService.documentFormattingEditProvider, languageFeaturesService.documentRangeFormattingEditProvider, model);
@@ -333,14 +321,13 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
         if (typeof pick === 'number') {
             await instaService.invokeFunction(formatDocumentWithProvider, provider[pick], editor, FormattingMode.Explicit, CancellationToken.None);
         }
-        logFormatterTelemetry(telemetryService, 'document', provider, typeof pick === 'number' && provider[pick] || undefined);
     }
 });
 registerEditorAction(class FormatSelectionMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatSelection.multiple',
-            label: ( localize(6995, "Format Selection With...")),
+            label: ( localize(7141, "Format Selection With...")),
             alias: 'Format Code...',
             precondition: ( ContextKeyExpr.and(( ContextKeyExpr.and(EditorContextKeys.writable)), EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider)),
             contextMenuOpts: {
@@ -356,7 +343,6 @@ registerEditorAction(class FormatSelectionMultipleAction extends EditorAction {
         }
         const instaService = accessor.get(IInstantiationService);
         const languageFeaturesService = accessor.get(ILanguageFeaturesService);
-        const telemetryService = accessor.get(ITelemetryService);
         const model = editor.getModel();
         let range = editor.getSelection();
         if (range.isEmpty()) {
@@ -372,7 +358,6 @@ registerEditorAction(class FormatSelectionMultipleAction extends EditorAction {
         if (typeof pick === 'number') {
             await instaService.invokeFunction(formatDocumentRangesWithProvider, provider[pick], editor, range, CancellationToken.None, true);
         }
-        logFormatterTelemetry(telemetryService, 'range', provider, typeof pick === 'number' && provider[pick] || undefined);
     }
 });
 

package/vscode/src/vs/workbench/contrib/format/browser/formatActionsNone.js

@@ -15,7 +15,7 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatDocument.none',
-            label: ( localize2(6996, "Format Document")),
+            label: ( localize2(7142, "Format Document")),
             precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, ( EditorContextKeys.hasDocumentFormattingProvider.toNegated()))),
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -43,14 +43,14 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
             return commandService.executeCommand('editor.action.formatDocument');
         }
         else if (model.isTooLargeForSyncing()) {
-            notificationService.warn(( localize(6997, "This file cannot be formatted because it is too large")));
+            notificationService.warn(( localize(7143, "This file cannot be formatted because it is too large")));
         }
         else {
             const langName = model.getLanguageId();
-            const message = ( localize(6998, "There is no formatter for '{0}' files installed.", langName));
+            const message = ( localize(7144, "There is no formatter for '{0}' files installed.", langName));
             const { confirmed } = await dialogService.confirm({
                 message,
-                primaryButton: ( localize(6999, "&&Install Formatter..."))
+                primaryButton: ( localize(7145, "&&Install Formatter..."))
             });
             if (confirmed) {
                 extensionsWorkbenchService.openSearch(`category:formatters ${langName}`);

package/vscode/src/vs/workbench/contrib/format/browser/formatModified.js

@@ -19,7 +19,7 @@ registerEditorAction(class FormatModifiedAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatChanges',
-            label: ( localize2(7000, "Format Modified Lines")),
+            label: ( localize2(7146, "Format Modified Lines")),
             precondition: ( ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 EditorContextKeys.hasDocumentSelectionFormattingProvider

package/vscode/src/vs/workbench/contrib/inlayHints/browser/inlayHintsAccessibilty.js

@@ -24,7 +24,7 @@ let InlayHintsAccessibility = class InlayHintsAccessibility {
     static { this.IsReading = ( new RawContextKey(
         'isReadingLineWithInlayHints',
         false,
-        { type: 'boolean', description: ( localize(7001, "Whether the current line and its inlay hints are currently focused")) }
+        { type: 'boolean', description: ( localize(7147, "Whether the current line and its inlay hints are currently focused")) }
     )); }
     static { this.ID = 'editor.contrib.InlayHintsAccessibility'; }
     static get(editor) {
@@ -39,7 +39,7 @@ let InlayHintsAccessibility = class InlayHintsAccessibility {
         this._ariaElement.style.position = 'fixed';
         this._ariaElement.className = 'inlayhint-accessibility-element';
         this._ariaElement.tabIndex = 0;
-        this._ariaElement.setAttribute('aria-description', ( localize(7002, "Code with Inlay Hint Information")));
+        this._ariaElement.setAttribute('aria-description', ( localize(7148, "Code with Inlay Hint Information")));
         this._ctxIsReading = InlayHintsAccessibility_1.IsReading.bindTo(contextKeyService);
     }
     dispose() {
@@ -139,7 +139,7 @@ registerAction2(class StartReadHints extends EditorAction2 {
     constructor() {
         super({
             id: 'inlayHints.startReadingLineWithHint',
-            title: ( localize2(7003, "Read Line With Inline Hints")),
+            title: ( localize2(7149, "Read Line with Inline Hints")),
             precondition: EditorContextKeys.hasInlayHintsProvider,
             f1: true
         });
@@ -153,7 +153,7 @@ registerAction2(class StopReadHints extends EditorAction2 {
     constructor() {
         super({
             id: 'inlayHints.stopReadingLineWithHint',
-            title: ( localize2(7004, "Stop Inlay Hints Reading")),
+            title: ( localize2(7150, "Stop Inlay Hints Reading")),
             precondition: InlayHintsAccessibility.IsReading,
             f1: true,
             keybinding: {

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

@@ -11,8 +11,8 @@ class ListResizeColumnAction extends Action2 {
     constructor() {
         super({
             id: 'list.resizeColumn',
-            title: { value: ( localize(7213, "Resize Column")), original: 'Resize Column' },
-            category: { value: ( localize(7214, "List")), original: 'List' },
+            title: { value: ( localize(7361, "Resize Column")), original: 'Resize Column' },
+            category: { value: ( localize(7362, "List")), original: 'List' },
             precondition: WorkbenchListFocusContextKey,
             f1: true
         });

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

@@ -17,14 +17,14 @@ let TableColumnResizeQuickPick = class TableColumnResizeQuickPick extends Dispos
                 items.push({ label, index });
             }
         });
-        const column = await this._quickInputService.pick(items, { placeHolder: ( localize(7215, "Select the column to resize, type to filter.")) });
+        const column = await this._quickInputService.pick(items, { placeHolder: ( localize(7363, "Select the column to resize, type to filter.")) });
         if (!column) {
             return;
         }
         const value = await this._quickInputService.input({
-            placeHolder: ( localize(7216, "i.e. 20, 60, 100...")),
+            placeHolder: ( localize(7364, "i.e. 20, 60, 100...")),
             prompt: ( localize(
-                7217,
+                7365,
                 "Please enter a width in percentage for the '{0}' column.",
                 column.label
             )),
@@ -39,11 +39,11 @@ let TableColumnResizeQuickPick = class TableColumnResizeQuickPick extends Dispos
     async _validateColumnResizeValue(input) {
         const percentage = Number.parseInt(input);
         if (input && !Number.isInteger(percentage)) {
-            return localize(7218, "Please enter an integer.");
+            return localize(7366, "Please enter an integer.");
         }
         else if (percentage < 0 || percentage > 100) {
             return localize(
-                7219,
+                7367,
                 "Please enter a number greater than 0 and less than or equal to 100."
             );
         }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service.d.ts

@@ -0,0 +1,7 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { IMcpConfigPath } from "@codingame/monaco-vscode-mcp-service-override/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService";
+export interface IMcpConfigPathsService {
+    _serviceBrand: undefined;
+    readonly paths: IObservable<readonly IMcpConfigPath[]>;
+}
+export declare const IMcpConfigPathsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMcpConfigPathsService>;

package/vscode/src/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service.js

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

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistryTypes.d.ts

@@ -0,0 +1,28 @@
+import { Event } from "../../../../base/common/event.js";
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { ILogger, LogLevel } from "../../../../platform/log/common/log.js";
+import { McpCollectionDefinition, McpCollectionReference, McpConnectionState, McpDefinitionReference, McpServerDefinition, McpServerLaunch } from "./mcpTypes.js";
+import { MCP } from "@codingame/monaco-vscode-mcp-service-override/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol";
+export interface IMcpMessageTransport extends IDisposable {
+    readonly state: IObservable<McpConnectionState>;
+    readonly onDidLog: Event<{
+        level: LogLevel;
+        message: string;
+    }>;
+    readonly onDidReceiveMessage: Event<MCP.JSONRPCMessage>;
+    send(message: MCP.JSONRPCMessage): void;
+    stop(): void;
+}
+export interface IMcpHostDelegate {
+    readonly priority: number;
+    waitForInitialProviderPromises(): Promise<void>;
+    canStart(collectionDefinition: McpCollectionDefinition, serverDefinition: McpServerDefinition): boolean;
+    start(collectionDefinition: McpCollectionDefinition, serverDefinition: McpServerDefinition, resolvedLaunch: McpServerLaunch): IMcpMessageTransport;
+}
+export interface IMcpResolveConnectionOptions {
+    logger: ILogger;
+    collectionRef: McpCollectionReference;
+    definitionRef: McpDefinitionReference;
+    forceTrust?: boolean;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service.d.ts

@@ -0,0 +1,29 @@
+import { Event } from "../../../../base/common/event.js";
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { ConfigurationTarget } from "../../../../platform/configuration/common/configuration.js";
+import { StorageScope } from "../../../../platform/storage/common/storage.js";
+import { IWorkspaceFolderData } from "../../../../platform/workspace/common/workspace.js";
+import { IResolvedValue } from "../../../services/configurationResolver/common/configurationResolverExpression.js";
+import { IMcpHostDelegate, IMcpResolveConnectionOptions } from "./mcpRegistryTypes.js";
+import { McpCollectionDefinition, LazyCollectionState, McpCollectionReference, IMcpServerConnection } from "./mcpTypes.js";
+export declare const IMcpRegistry: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMcpRegistry>;
+export interface IMcpRegistry {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeInputs: Event<void>;
+    readonly collections: IObservable<readonly McpCollectionDefinition[]>;
+    readonly delegates: readonly IMcpHostDelegate[];
+    readonly lazyCollectionState: IObservable<LazyCollectionState>;
+    collectionToolPrefix(collection: McpCollectionReference): IObservable<string>;
+    discoverCollections(): Promise<McpCollectionDefinition[]>;
+    registerDelegate(delegate: IMcpHostDelegate): IDisposable;
+    registerCollection(collection: McpCollectionDefinition): IDisposable;
+    resetTrust(): void;
+    getTrust(collection: McpCollectionReference): IObservable<boolean | undefined>;
+    clearSavedInputs(scope: StorageScope, inputId?: string): Promise<void>;
+    editSavedInput(inputId: string, folderData: IWorkspaceFolderData | undefined, configSection: string, target: ConfigurationTarget): Promise<void>;
+    getSavedInputs(scope: StorageScope): Promise<{
+        [id: string]: IResolvedValue;
+    }>;
+    resolveConnection(options: IMcpResolveConnectionOptions): Promise<IMcpServerConnection | undefined>;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service.js

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

package/vscode/src/vs/workbench/contrib/mcp/common/mcpTypes.d.ts

@@ -0,0 +1,205 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { URI, UriComponents } from "../../../../base/common/uri.js";
+import { Location } from "../../../../editor/common/languages.js";
+import { ConfigurationTarget } from "../../../../platform/configuration/common/configuration.js";
+import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
+import { StorageScope } from "../../../../platform/storage/common/storage.js";
+import { IWorkspaceFolderData } from "../../../../platform/workspace/common/workspace.js";
+import { McpServerRequestHandler } from "@codingame/monaco-vscode-mcp-service-override/vscode/vs/workbench/contrib/mcp/common/mcpServerRequestHandler";
+import { MCP } from "@codingame/monaco-vscode-mcp-service-override/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol";
+export declare const extensionMcpCollectionPrefix = "ext.";
+export declare function extensionPrefixedIdentifier(identifier: ExtensionIdentifier, id: string): string;
+export interface McpCollectionDefinition {
+    readonly remoteAuthority: string | null;
+    readonly id: string;
+    readonly label: string;
+    readonly serverDefinitions: IObservable<readonly McpServerDefinition[]>;
+    readonly isTrustedByDefault: boolean;
+    readonly scope: StorageScope;
+    readonly lazy?: {
+        isCached: boolean;
+        load(): Promise<void>;
+        removed?(): void;
+    };
+    readonly presentation?: {
+        readonly order?: number;
+        readonly origin?: URI;
+    };
+}
+export declare enum McpCollectionSortOrder {
+    WorkspaceFolder = 0,
+    Workspace = 100,
+    User = 200,
+    Extension = 300,
+    Filesystem = 400,
+    RemoteBoost = -50
+}
+export declare namespace McpCollectionDefinition {
+    interface FromExtHost {
+        readonly id: string;
+        readonly label: string;
+        readonly isTrustedByDefault: boolean;
+        readonly scope: StorageScope;
+    }
+    function equals(a: McpCollectionDefinition, b: McpCollectionDefinition): boolean;
+}
+export interface McpServerDefinition {
+    readonly id: string;
+    readonly label: string;
+    readonly launch: McpServerLaunch;
+    readonly roots?: URI[] | undefined;
+    readonly variableReplacement?: McpServerDefinitionVariableReplacement;
+    readonly presentation?: {
+        readonly order?: number;
+        readonly origin?: Location;
+    };
+}
+export declare namespace McpServerDefinition {
+    interface Serialized {
+        readonly id: string;
+        readonly label: string;
+        readonly launch: McpServerLaunch.Serialized;
+        readonly variableReplacement?: McpServerDefinitionVariableReplacement.Serialized;
+    }
+    function toSerialized(def: McpServerDefinition): McpServerDefinition.Serialized;
+    function fromSerialized(def: McpServerDefinition.Serialized): McpServerDefinition;
+    function equals(a: McpServerDefinition, b: McpServerDefinition): boolean;
+}
+export interface McpServerDefinitionVariableReplacement {
+    section?: string;
+    folder?: IWorkspaceFolderData;
+    target: ConfigurationTarget;
+}
+export declare namespace McpServerDefinitionVariableReplacement {
+    interface Serialized {
+        target: ConfigurationTarget;
+        section?: string;
+        folder?: {
+            name: string;
+            index: number;
+            uri: UriComponents;
+        };
+    }
+    function toSerialized(def: McpServerDefinitionVariableReplacement): McpServerDefinitionVariableReplacement.Serialized;
+    function fromSerialized(def: McpServerDefinitionVariableReplacement.Serialized): McpServerDefinitionVariableReplacement;
+}
+export declare enum LazyCollectionState {
+    HasUnknown = 0,
+    LoadingUnknown = 1,
+    AllKnown = 2
+}
+export interface McpCollectionReference {
+    id: string;
+    label: string;
+    presentation?: McpCollectionDefinition["presentation"];
+}
+export interface McpDefinitionReference {
+    id: string;
+    label: string;
+}
+export interface IMcpServer extends IDisposable {
+    readonly collection: McpCollectionReference;
+    readonly definition: McpDefinitionReference;
+    readonly connection: IObservable<IMcpServerConnection | undefined>;
+    readonly connectionState: IObservable<McpConnectionState>;
+    readonly trusted: IObservable<boolean | undefined>;
+    showOutput(): void;
+    start(isFromInteraction?: boolean): Promise<McpConnectionState>;
+    stop(): Promise<void>;
+    readonly toolsState: IObservable<McpServerToolsState>;
+    readonly tools: IObservable<readonly IMcpTool[]>;
+}
+export declare enum McpServerToolsState {
+    Unknown = 0,
+    Cached = 1,
+    RefreshingFromUnknown = 2,
+    RefreshingFromCached = 3,
+    Live = 4
+}
+export interface IMcpTool {
+    readonly id: string;
+    readonly definition: MCP.Tool;
+    call(params: Record<string, unknown>, token?: CancellationToken): Promise<MCP.CallToolResult>;
+}
+export declare enum McpServerTransportType {
+    Stdio = 1,
+    SSE = 2
+}
+export interface McpServerTransportStdio {
+    readonly type: McpServerTransportType.Stdio;
+    readonly cwd: URI | undefined;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env: Record<string, string | number | null>;
+    readonly envFile: string | undefined;
+}
+export interface McpServerTransportSSE {
+    readonly type: McpServerTransportType.SSE;
+    readonly uri: URI;
+    readonly headers: [
+        string,
+        string
+    ][];
+}
+export type McpServerLaunch = McpServerTransportStdio | McpServerTransportSSE;
+export declare namespace McpServerLaunch {
+    type Serialized = {
+        type: McpServerTransportType.SSE;
+        uri: UriComponents;
+        headers: [
+            string,
+            string
+        ][];
+    } | {
+        type: McpServerTransportType.Stdio;
+        cwd: UriComponents | undefined;
+        command: string;
+        args: readonly string[];
+        env: Record<string, string | number | null>;
+        envFile: string | undefined;
+    };
+    function toSerialized(launch: McpServerLaunch): McpServerLaunch.Serialized;
+    function fromSerialized(launch: McpServerLaunch.Serialized): McpServerLaunch;
+}
+export interface IMcpServerConnection extends IDisposable {
+    readonly definition: McpServerDefinition;
+    readonly state: IObservable<McpConnectionState>;
+    readonly handler: IObservable<McpServerRequestHandler | undefined>;
+    start(): Promise<McpConnectionState>;
+    stop(): Promise<void>;
+}
+export declare namespace McpConnectionState {
+    enum Kind {
+        Stopped = 0,
+        Starting = 1,
+        Running = 2,
+        Error = 3
+    }
+    const toString: (s: McpConnectionState) => string;
+    const toKindString: (s: McpConnectionState.Kind) => string;
+    const canBeStarted: (s: Kind) => s is Kind.Stopped | Kind.Error;
+    const isRunning: (s: McpConnectionState) => boolean;
+    interface Stopped {
+        readonly state: Kind.Stopped;
+    }
+    interface Starting {
+        readonly state: Kind.Starting;
+    }
+    interface Running {
+        readonly state: Kind.Running;
+    }
+    interface Error {
+        readonly state: Kind.Error;
+        readonly message: string;
+    }
+}
+export type McpConnectionState = McpConnectionState.Stopped | McpConnectionState.Starting | McpConnectionState.Running | McpConnectionState.Error;
+export declare class MpcResponseError extends Error {
+    readonly code: number;
+    readonly data: unknown;
+    constructor(message: string, code: number, data: unknown);
+}
+export declare class McpConnectionFailedError extends Error {
+}