@codingame/monaco-vscode-mcp-service-override 36.2.6 → 37.0.0

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

@@ -9,14 +9,60 @@ import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { asText, asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import { asText, isSuccess, asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
 import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
-import { TransportType, RegistryType, GalleryMcpServerStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement';
-import { McpGalleryManifestStatus, getMcpGalleryManifestResourceUri, McpGalleryResourceType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpGalleryManifest';
+import { RegistryType, TransportType, McpGalleryResolveStatus, GalleryMcpServerStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement';
+import { getMcpGalleryManifestResourceUri, McpGalleryResourceType, McpGalleryManifestStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpGalleryManifest';
 import { IMcpGalleryManifestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpGalleryManifest.service';
 import { CancellationError, isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { isString, isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 
+function toSupportedPackageRegistryType(input) {
+    switch (input) {
+    case "npm":
+        return RegistryType.NODE;
+    case "docker":
+    case "docker-hub":
+    case "oci":
+        return RegistryType.DOCKER;
+    case "pypi":
+        return RegistryType.PYTHON;
+    case "nuget":
+        return RegistryType.NUGET;
+    default:
+        return undefined;
+    }
+}
+function filterMcpPackages(packages, getRegistryType, convert) {
+    if (!packages) {
+        return undefined;
+    }
+    const result = [];
+    for (const serverPackage of packages) {
+        const registryType = toSupportedPackageRegistryType(getRegistryType(serverPackage));
+        if (registryType) {
+            result.push(convert(serverPackage, registryType));
+        }
+    }
+    return result;
+}
+function getMcpServerUrlInGallery(mcpServerUrl, mcpGalleryManifest) {
+    const mcpGalleryUrl = getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpServersQueryService) ?? mcpGalleryManifest.url;
+    try {
+        const serverUrl = ( new URL(mcpServerUrl));
+        const galleryUrl = ( new URL(mcpGalleryUrl));
+        if ((serverUrl.protocol !== `${Schemas.http}:` && serverUrl.protocol !== `${Schemas.https}:`) || serverUrl.username || serverUrl.password || galleryUrl.username || galleryUrl.password || serverUrl.origin !== galleryUrl.origin) {
+            return undefined;
+        }
+        const galleryPath = galleryUrl.pathname.replace(/\/+$/, "");
+        if (serverUrl.pathname !== galleryPath && !serverUrl.pathname.startsWith(`${galleryPath}/`)) {
+            return undefined;
+        }
+        return serverUrl.href;
+    } catch {
+        return undefined;
+    }
+}
 var IconMimeType;
 (function(IconMimeType) {
     IconMimeType["PNG"] = "image/png";
@@ -44,7 +90,7 @@ var McpServerSchemaVersion_v2025_07_09;
             for (const server of from.servers) {
                 const rawServer = this.toRawGalleryMcpServer(server);
                 if (!rawServer) {
-                    return undefined;
+                    continue;
                 }
                 servers.push(rawServer);
             }
@@ -133,23 +179,26 @@ var McpServerSchemaVersion_v2025_07_09;
                     };
                 }
             }
-            function convertRegistryType(input) {
-                switch (input) {
-                case "npm":
-                    return RegistryType.NODE;
-                case "docker":
-                case "docker-hub":
-                case "oci":
-                    return RegistryType.DOCKER;
-                case "pypi":
-                    return RegistryType.PYTHON;
-                case "nuget":
-                    return RegistryType.NUGET;
-                case "mcpb":
-                    return RegistryType.MCPB;
-                default:
-                    return RegistryType.NODE;
-                }
+            const packages = filterMcpPackages(
+                from.packages,
+                serverPackage => serverPackage.registry_type ?? serverPackage.registry_name,
+                (serverPackage, registryType) => ({
+                    identifier: serverPackage.identifier ?? serverPackage.name,
+                    registryType,
+                    version: serverPackage.version,
+                    fileSha256: serverPackage.file_sha256,
+                    registryBaseUrl: serverPackage.registry_base_url,
+                    transport: serverPackage.transport ? convertTransport(serverPackage.transport) : {
+                        type: TransportType.STDIO
+                    },
+                    packageArguments: serverPackage.package_arguments?.map(convertServerArgument),
+                    runtimeHint: serverPackage.runtime_hint,
+                    runtimeArguments: serverPackage.runtime_arguments?.map(convertServerArgument),
+                    environmentVariables: serverPackage.environment_variables?.map(convertKeyValueInput)
+                })
+            );
+            if (!packages?.length && !from.remotes?.length) {
+                return undefined;
             }
             const gitHubInfo = from._meta["io.modelcontextprotocol.registry/publisher-provided"]?.github;
             return {
@@ -165,20 +214,7 @@ var McpServerSchemaVersion_v2025_07_09;
                 version: from.version,
                 createdAt: from.created_at,
                 updatedAt: from.updated_at,
-                packages: from.packages?.map(p => ({
-                    identifier: p.identifier ?? p.name,
-                    registryType: convertRegistryType(p.registry_type ?? p.registry_name),
-                    version: p.version,
-                    fileSha256: p.file_sha256,
-                    registryBaseUrl: p.registry_base_url,
-                    transport: p.transport ? convertTransport(p.transport) : {
-                        type: TransportType.STDIO
-                    },
-                    packageArguments: p.package_arguments?.map(convertServerArgument),
-                    runtimeHint: p.runtime_hint,
-                    runtimeArguments: p.runtime_arguments?.map(convertServerArgument),
-                    environmentVariables: p.environment_variables?.map(convertKeyValueInput)
-                })),
+                packages,
                 remotes: from.remotes?.map(remote => {
                     const type = remote.type ?? remote.transport_type ?? remote.transport;
                     return {
@@ -227,11 +263,7 @@ var McpServerSchemaVersion_v0_1;
             for (const server of from.servers) {
                 const rawServer = this.toRawGalleryMcpServer(server);
                 if (!rawServer) {
-                    if (servers.length === 0) {
-                        return undefined;
-                    } else {
-                        continue;
-                    }
+                    continue;
                 }
                 servers.push(rawServer);
             }
@@ -253,6 +285,17 @@ var McpServerSchemaVersion_v0_1;
                 ...apicInfo
             } = from._meta;
             const githubInfo = from.server._meta?.["io.modelcontextprotocol.registry/publisher-provided"]?.github;
+            const packages = filterMcpPackages(
+                from.server.packages,
+                serverPackage => serverPackage.registryType,
+                (serverPackage, registryType) => ({
+                    ...serverPackage,
+                    registryType
+                })
+            );
+            if (!packages?.length && !from.server.remotes?.length) {
+                return undefined;
+            }
             return {
                 name: from.server.name,
                 description: from.server.description,
@@ -266,7 +309,7 @@ var McpServerSchemaVersion_v0_1;
                 readme: githubInfo?.readme,
                 icons: from.server.icons,
                 websiteUrl: from.server.websiteUrl,
-                packages: from.server.packages,
+                packages,
                 remotes: from.server.remotes,
                 status: registryInfo?.status,
                 registryInfo,
@@ -281,28 +324,38 @@ var McpServerSchemaVersion_v0;
 (function(McpServerSchemaVersion_v0) {
     McpServerSchemaVersion_v0.VERSION = "v0";
     class Serializer {
-        constructor() {
-            this.galleryMcpServerDataSerializers = [];
-            this.galleryMcpServerDataSerializers.push(McpServerSchemaVersion_v0_1.SERIALIZER);
-            this.galleryMcpServerDataSerializers.push(McpServerSchemaVersion_v2025_07_09.SERIALIZER);
-        }
         toRawGalleryMcpServerResult(input) {
-            for (const serializer of this.galleryMcpServerDataSerializers) {
-                const result = serializer.toRawGalleryMcpServerResult(input);
-                if (result) {
-                    return result;
+            if (!isObject(input)) {
+                return undefined;
+            }
+            const candidate = input;
+            if (!Array.isArray(candidate.servers) || !isObject(candidate.metadata)) {
+                return undefined;
+            }
+            const metadata = candidate.metadata;
+            if (metadata.count !== undefined && typeof metadata.count !== "number") {
+                return undefined;
+            }
+            const servers = [];
+            for (const server of candidate.servers) {
+                const rawServer = this.toRawGalleryMcpServer(server);
+                if (rawServer) {
+                    servers.push(rawServer);
                 }
             }
-            return undefined;
+            return {
+                metadata: {
+                    count: metadata.count ?? 0,
+                    nextCursor: isString(metadata.nextCursor) ? metadata.nextCursor : isString(metadata.next_cursor) ? metadata.next_cursor : undefined
+                },
+                servers
+            };
         }
         toRawGalleryMcpServer(input) {
-            for (const serializer of this.galleryMcpServerDataSerializers) {
-                const result = serializer.toRawGalleryMcpServer(input);
-                if (result) {
-                    return result;
-                }
+            if (isObject(input) && isObject(input.server)) {
+                return McpServerSchemaVersion_v0_1.SERIALIZER.toRawGalleryMcpServer(input);
             }
-            return undefined;
+            return McpServerSchemaVersion_v2025_07_09.SERIALIZER.toRawGalleryMcpServer(input);
         }
     }
     McpServerSchemaVersion_v0.SERIALIZER = ( new Serializer());
@@ -410,18 +463,43 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         };
     }
     async getMcpServersFromGallery(infos) {
+        const resolved = await this.resolveMcpServersFromGallery(infos);
+        const mcpServers = [];
+        for (const result of ( resolved.values())) {
+            if (result.status === McpGalleryResolveStatus.Found) {
+                mcpServers.push(result.server);
+            }
+        }
+        return mcpServers;
+    }
+    async resolveMcpServersFromGallery(infos) {
+        const result = ( new Map());
         const mcpGalleryManifest = await this.mcpGalleryManifestService.getMcpGalleryManifest();
         if (!mcpGalleryManifest) {
-            return [];
+            for (const info of infos) {
+                result.set(info.name, {
+                    status: McpGalleryResolveStatus.Failed
+                });
+            }
+            return result;
         }
-        const mcpServers = [];
-        await Promise.allSettled(( infos.map(async info => {
-            const mcpServer = await this.getMcpServerByName(info, mcpGalleryManifest);
-            if (mcpServer) {
-                mcpServers.push(mcpServer);
+        await Promise.all(( infos.map(async info => {
+            try {
+                const mcpServer = await this.getMcpServerByName(info, mcpGalleryManifest);
+                result.set(info.name, mcpServer ? {
+                    status: McpGalleryResolveStatus.Found,
+                    server: mcpServer
+                } : {
+                    status: McpGalleryResolveStatus.NotFound
+                });
+            } catch (error) {
+                this.logService.warn(`Failed to resolve MCP server '${info.name}' from gallery: ${error}`);
+                result.set(info.name, {
+                    status: McpGalleryResolveStatus.Failed
+                });
             }
         })));
-        return mcpServers;
+        return result;
     }
     async getMcpServerByName(
         {
@@ -430,33 +508,44 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         },
         mcpGalleryManifest
     ) {
-        const mcpServerUrl = this.getLatestServerVersionUrl(name, mcpGalleryManifest);
-        if (mcpServerUrl) {
-            const mcpServer = await this.getMcpServer(mcpServerUrl);
-            if (mcpServer) {
-                return mcpServer;
+        const urls = [
+            this.getLatestServerVersionUrl(name, mcpGalleryManifest),
+            this.getNamedServerUrl(name, mcpGalleryManifest),
+            id ? this.getServerIdUrl(id, mcpGalleryManifest) : undefined
+        ];
+        let attempted = false;
+        let lastError;
+        for (const url of urls) {
+            if (!url) {
+                continue;
             }
-        }
-        const byNameUrl = this.getNamedServerUrl(name, mcpGalleryManifest);
-        if (byNameUrl) {
-            const mcpServer = await this.getMcpServer(byNameUrl);
-            if (mcpServer) {
-                return mcpServer;
+            attempted = true;
+            try {
+                const mcpServer = await this.getMcpServer(url, mcpGalleryManifest);
+                if (mcpServer) {
+                    if (mcpServer.name === name) {
+                        return mcpServer;
+                    }
+                    lastError = ( new Error(`MCP server lookup for '${name}' returned '${mcpServer.name}'`));
+                }
+            } catch (error) {
+                lastError = error;
             }
         }
-        const byIdUrl = id ? this.getServerIdUrl(id, mcpGalleryManifest) : undefined;
-        if (byIdUrl) {
-            const mcpServer = await this.getMcpServer(byIdUrl);
-            if (mcpServer) {
-                return mcpServer;
-            }
+        if (!attempted) {
+            throw ( new Error(
+                `Cannot resolve MCP server '${name}': registry manifest has no server lookup endpoint`
+            ));
+        }
+        if (lastError !== undefined) {
+            throw lastError;
         }
         return undefined;
     }
     async getReadme(gallery, token) {
         const readmeUrl = gallery.readmeUrl;
         if (!readmeUrl) {
-            return Promise.resolve(( localize(2181, "No README available")));
+            return Promise.resolve(( localize(2355, "No README available")));
         }
         const uri = ( URI.parse(readmeUrl));
         if (uri.scheme === Schemas.file) {
@@ -468,7 +557,7 @@ let McpGalleryService = class McpGalleryService extends Disposable {
             }
         }
         if (uri.authority !== "raw.githubusercontent.com") {
-            return ( new MarkdownString(( localize(2182, "You can find information about this server [here]({0})", readmeUrl)))).value;
+            return ( new MarkdownString(( localize(2356, "You can find information about this server [here]({0})", readmeUrl)))).value;
         }
         const context = await this.requestService.request({
             type: "GET",
@@ -615,6 +704,15 @@ let McpGalleryService = class McpGalleryService extends Disposable {
                 }
             };
         }
+        if (!isSuccess(context)) {
+            this.logService.error(`Failed to query MCP gallery: Server returned ${context.res.statusCode}`);
+            return {
+                servers: [],
+                metadata: {
+                    count: 0
+                }
+            };
+        }
         const data = await asJson(context);
         if (!data) {
             return {
@@ -631,27 +729,37 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         return result;
     }
     async getMcpServer(mcpServerUrl, mcpGalleryManifest) {
+        const manifest = mcpGalleryManifest ?? (await this.mcpGalleryManifestService.getMcpGalleryManifest());
+        if (!manifest) {
+            throw ( new Error("Cannot fetch MCP server because no MCP gallery is configured"));
+        }
+        const validatedMcpServerUrl = getMcpServerUrlInGallery(mcpServerUrl, manifest);
+        if (!validatedMcpServerUrl) {
+            throw ( new Error("Cannot fetch MCP server from outside the configured MCP gallery"));
+        }
         const context = await this.requestService.request({
             type: "GET",
-            url: mcpServerUrl,
+            url: validatedMcpServerUrl,
+            followRedirects: 0,
             callSite: "mcpGalleryService.getMcpServer"
         }, CancellationToken.None);
-        if (context.res.statusCode && context.res.statusCode >= 400 && context.res.statusCode < 500) {
+        if (context.res.statusCode === 404) {
             return undefined;
         }
+        if (!isSuccess(context)) {
+            throw ( new Error(
+                `Failed to fetch MCP server from ${mcpServerUrl}: server responded with ${context.res.statusCode}`
+            ));
+        }
         const data = await asJson(context);
         if (!data) {
-            return undefined;
-        }
-        if (!mcpGalleryManifest) {
-            mcpGalleryManifest = await this.mcpGalleryManifestService.getMcpGalleryManifest();
+            throw ( new Error(`Failed to fetch MCP server from ${mcpServerUrl}: empty response`));
         }
-        mcpGalleryManifest = mcpGalleryManifest && mcpServerUrl.startsWith(mcpGalleryManifest.url) ? mcpGalleryManifest : null;
-        const server = this.serializeMcpServer(data, mcpGalleryManifest);
+        const server = this.serializeMcpServer(data, manifest);
         if (!server) {
             throw ( new Error(`Failed to serialize MCP server from ${mcpServerUrl}`, data));
         }
-        return this.toGalleryMcpServer(server, mcpGalleryManifest);
+        return this.toGalleryMcpServer(server, manifest);
     }
     serializeMcpServer(data, mcpGalleryManifest) {
         return this.getSerializer(mcpGalleryManifest)?.toRawGalleryMcpServer(data);

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

@@ -4,6 +4,7 @@ import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { Queue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { getParseErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonErrorMessages';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { ConfigurationTarget, ConfigurationTargetToString } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
@@ -72,7 +73,7 @@ let McpResourceScannerService = class McpResourceScannerService extends Disposab
                     allowEmptyContent: true
                 }) || {};
                 if (errors.length > 0) {
-                    throw ( new Error("Failed to parse scanned MCP servers: " + errors.join(", ")));
+                    throw ( new Error("Failed to parse scanned MCP servers: " + ( errors.map(e => `[${e.offset}, ${e.length}] ${getParseErrorMessage(e.error)}`)).join(", ")));
                 }
                 if (target === ConfigurationTarget.USER) {
                     scannedMcpServers = this.fromUserMcpServers(result);
@@ -130,7 +131,7 @@ let McpResourceScannerService = class McpResourceScannerService extends Disposab
                 allowEmptyContent: true
             });
             if (errors.length > 0) {
-                throw ( new Error("Failed to parse scanned MCP servers: " + errors.join(", ")));
+                throw ( new Error("Failed to parse scanned MCP servers: " + ( errors.map(e => `[${e.offset}, ${e.length}] ${getParseErrorMessage(e.error)}`)).join(", ")));
             }
         } catch (error) {
             if (toFileOperationResult(error) !== FileOperationResult.FILE_NOT_FOUND) {

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

@@ -4,6 +4,7 @@ export declare const NativeMcpDiscoveryHelperChannelName = "NativeMcpDiscoveryHe
 export interface INativeMcpDiscoveryData {
     platform: Platform;
     homedir: URI;
+    copilotHome?: URI;
     winAppData?: URI;
     xdgHome?: URI;
 }

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

@@ -113,16 +113,16 @@ registerWorkbenchContribution2(
 const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
 jsonRegistry.registerSchema(mcpSchemaId, mcpServerSchema);
 ( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
-    EditorPaneDescriptor.create(McpServerEditor, McpServerEditor.ID, ( localize(11759, "MCP Server"))),
+    EditorPaneDescriptor.create(McpServerEditor, McpServerEditor.ID, ( localize(13506, "MCP Server"))),
     [( new SyncDescriptor(McpServerEditorInput))]
 );
 ( Registry.as(Extensions$1.Quickaccess)).registerQuickAccessProvider({
     ctor: McpResourceQuickAccess,
     prefix: McpResourceQuickAccess.PREFIX,
     when: ChatContextKeys.enabled,
-    placeholder: ( localize(11760, "Filter to an MCP resource")),
+    placeholder: ( localize(13507, "Filter to an MCP resource")),
     helpEntries: [{
-        description: ( localize(11761, "MCP Server Resources")),
+        description: ( localize(13508, "MCP Server Resources")),
         commandId: McpCommandIds.AddConfiguration
     }]
 });

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

@@ -43,7 +43,7 @@ let McpAddContextContribution = class McpAddContextContribution extends Disposab
     _registerAddContextMenu() {
         this._addContextMenu.value = this._chatContextPickService.registerChatContextItem({
             type: "pickerPick",
-            label: ( localize(11762, "MCP Resources...")),
+            label: ( localize(13509, "MCP Resources...")),
             icon: Codicon.mcp,
             isEnabled(widget) {
                 return !!widget.attachmentCapabilities.supportsMCPAttachments;
@@ -51,7 +51,7 @@ let McpAddContextContribution = class McpAddContextContribution extends Disposab
             asPicker: () => {
                 const helper = this._instantiationService.createInstance(McpResourcePickHelper);
                 return {
-                    placeholder: ( localize(11763, "Select MCP Resource...")),
+                    placeholder: ( localize(13510, "Select MCP Resource...")),
                     picks: (_query, token) => this._getResourcePicks(token, helper),
                     goBack: () => {
                         return helper.navigateBack();

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpCommands.d.ts

@@ -8,6 +8,7 @@ import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { IInstantiationService, ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { StorageScope } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IAgentHostCustomizationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.service";
 import { IChatElicitationRequest, IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IMcpServer, IMcpServerStartOpts } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
@@ -18,6 +19,8 @@ export declare class ListMcpServerCommand extends Action2 {
     private _runLocal;
     private _runAgentHost;
 }
+type IAgentHostMcpServer = ReturnType<IAgentHostCustomizationService["getMcpServers"]>[number];
+export declare function findLocalMcpServer(mcpService: IMcpService, server: IAgentHostMcpServer): IMcpServer | undefined;
 export declare class McpAgentHostServerOptionsCommand extends Action2 {
     constructor();
     run(accessor: ServicesAccessor, agentHostSession: URI, customizationId: string): Promise<void>;
@@ -71,19 +74,23 @@ export declare class ShowOutput extends Action2 {
     constructor();
     run(accessor: ServicesAccessor, serverId: string): void;
 }
+interface IAgentHostMcpServerCommandArg {
+    readonly agentHostSession: URI;
+    readonly serverId: string;
+}
 export declare class RestartServer extends Action2 {
     constructor();
-    run(accessor: ServicesAccessor, serverId: string, opts?: IMcpServerStartOpts): Promise<void>;
+    run(accessor: ServicesAccessor, serverId: string | IAgentHostMcpServerCommandArg, opts?: IMcpServerStartOpts): Promise<void>;
 }
 export declare class StartServer extends Action2 {
     constructor();
-    run(accessor: ServicesAccessor, serverId: string, opts?: IMcpServerStartOpts & {
+    run(accessor: ServicesAccessor, serverId: string | IAgentHostMcpServerCommandArg, opts?: IMcpServerStartOpts & {
         waitForLiveTools?: boolean;
     }): Promise<void>;
 }
 export declare class StopServer extends Action2 {
     constructor();
-    run(accessor: ServicesAccessor, serverId: string): Promise<void>;
+    run(accessor: ServicesAccessor, serverId: string | IAgentHostMcpServerCommandArg): Promise<void>;
 }
 export declare class McpBrowseCommand extends Action2 {
     constructor();