@codingame/monaco-vscode-mcp-service-override 21.6.0 → 22.0.0

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

@@ -9,22 +9,675 @@ 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 { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { asJson, asText } 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 { GalleryMcpServerStatus } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/platform/mcp/common/mcpManagement';
+import { TransportType, RegistryType, GalleryMcpServerStatus } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/platform/mcp/common/mcpManagement';
 import { McpGalleryManifestStatus, getMcpGalleryManifestResourceUri, McpGalleryResourceType } 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 { singlePagePager, PageIteratorPager } from '@codingame/monaco-vscode-62190c26-af1c-5f7a-a364-e05a59cfb7c7-common/vscode/vs/base/common/paging';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 
-function isIRawGalleryServersOldResult(obj) {
-    return obj && Array.isArray(obj.servers) && isIRawGalleryOldMcpServer(obj.servers[0]);
-}
-function isIRawGalleryOldMcpServer(obj) {
-    return obj && obj.server !== undefined;
-}
+var McpServerOldSchema;
+(function (McpServerOldSchema) {
+    class Serializer {
+        toRawGalleryMcpServerResult(input) {
+            if (!input || !Array.isArray(input.servers)) {
+                return undefined;
+            }
+            const from = input;
+            const servers = [];
+            for (const server of from.servers) {
+                const rawServer = this.toRawGalleryMcpServer(server);
+                if (!rawServer) {
+                    return undefined;
+                }
+                servers.push(rawServer);
+            }
+            return {
+                metadata: from.metadata,
+                servers
+            };
+        }
+        toRawGalleryMcpServer(input) {
+            if (!input || !input.server) {
+                return undefined;
+            }
+            const from = input;
+            const registryInfo = from['x-io.modelcontextprotocol.registry'];
+            function convertServerInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                };
+            }
+            function convertVariables(variables) {
+                const result = {};
+                for (const [key, value] of Object.entries(variables)) {
+                    result[key] = convertServerInput(value);
+                }
+                return result;
+            }
+            function convertServerArgument(arg) {
+                if (arg.type === 'positional') {
+                    return {
+                        ...arg,
+                        valueHint: arg.value_hint,
+                        isRepeated: arg.is_repeated,
+                        isRequired: arg.is_required,
+                        isSecret: arg.is_secret,
+                        variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                    };
+                }
+                return {
+                    ...arg,
+                    isRepeated: arg.is_repeated,
+                    isRequired: arg.is_required,
+                    isSecret: arg.is_secret,
+                    variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                };
+            }
+            function convertKeyValueInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                    variables: input.variables ? convertVariables(input.variables) : undefined,
+                };
+            }
+            function convertTransport(input) {
+                switch (input.type) {
+                    case 'stdio':
+                        return {
+                            type: TransportType.STDIO,
+                        };
+                    case 'streamable-http':
+                        return {
+                            type: TransportType.STREAMABLE_HTTP,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    case 'sse':
+                        return {
+                            type: TransportType.SSE,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    default:
+                        return undefined;
+                }
+            }
+            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;
+                }
+            }
+            return {
+                name: from.server.name,
+                description: from.server.description,
+                repository: from.server.repository ? {
+                    url: from.server.repository.url,
+                    source: from.server.repository.source,
+                    id: from.server.repository.id,
+                    readme: from.server.repository.readme
+                } : undefined,
+                version: from.server.version_detail.version,
+                createdAt: from.server.created_at,
+                updatedAt: from.server.updated_at,
+                packages: from.server.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) : undefined,
+                    packageArguments: p.package_arguments?.map(convertServerArgument),
+                    runtimeHint: p.runtime_hint,
+                    runtimeArguments: p.runtime_arguments?.map(convertServerArgument),
+                    environmentVariables: p.environment_variables?.map(convertKeyValueInput),
+                })),
+                remotes: from.server.remotes?.map(remote => {
+                    const type = remote.type ?? remote.transport_type ?? remote.transport;
+                    return {
+                        type: type === TransportType.SSE ? TransportType.SSE : TransportType.STREAMABLE_HTTP,
+                        url: remote.url,
+                        headers: remote.headers?.map(convertKeyValueInput)
+                    };
+                }),
+                registryInfo: {
+                    id: registryInfo.id,
+                    isLatest: registryInfo.is_latest,
+                    publishedAt: registryInfo.published_at,
+                    updatedAt: registryInfo.updated_at,
+                },
+                githubInfo: from['x-github'],
+            };
+        }
+    }
+    McpServerOldSchema.SERIALIZER = ( new Serializer());
+})(McpServerOldSchema || (McpServerOldSchema = {}));
+var McpServer1ESSchema;
+(function (McpServer1ESSchema) {
+    class Serializer {
+        toRawGalleryMcpServerResult(input) {
+            if (!input || !Array.isArray(input.servers)) {
+                return undefined;
+            }
+            const from = input;
+            const servers = [];
+            for (const server of from.servers) {
+                const rawServer = this.toRawGalleryMcpServer(server);
+                if (!rawServer) {
+                    return undefined;
+                }
+                servers.push(rawServer);
+            }
+            return {
+                metadata: from.metadata,
+                servers
+            };
+        }
+        toRawGalleryMcpServer(input) {
+            if (!input || input.server || input.$schema) {
+                return undefined;
+            }
+            const from = input;
+            function convertServerInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                };
+            }
+            function convertVariables(variables) {
+                const result = {};
+                for (const [key, value] of Object.entries(variables)) {
+                    result[key] = convertServerInput(value);
+                }
+                return result;
+            }
+            function convertServerArgument(arg) {
+                if (arg.type === 'positional') {
+                    return {
+                        ...arg,
+                        valueHint: arg.value_hint,
+                        isRepeated: arg.is_repeated,
+                        isRequired: arg.is_required,
+                        isSecret: arg.is_secret,
+                        variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                    };
+                }
+                return {
+                    ...arg,
+                    isRepeated: arg.is_repeated,
+                    isRequired: arg.is_required,
+                    isSecret: arg.is_secret,
+                    variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                };
+            }
+            function convertKeyValueInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                    variables: input.variables ? convertVariables(input.variables) : undefined,
+                };
+            }
+            function convertTransport(input) {
+                switch (input.type) {
+                    case 'stdio':
+                        return {
+                            type: TransportType.STDIO,
+                        };
+                    case 'streamable-http':
+                        return {
+                            type: TransportType.STREAMABLE_HTTP,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    case 'sse':
+                        return {
+                            type: TransportType.SSE,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    default:
+                        return undefined;
+                }
+            }
+            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;
+                }
+            }
+            return {
+                name: from.name,
+                description: from.description,
+                repository: from.repository ? {
+                    url: from.repository.url,
+                    source: from.repository.source,
+                    id: from.repository.id,
+                    readme: from.repository.readme
+                } : undefined,
+                version: from.version_detail.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) : undefined,
+                    packageArguments: p.package_arguments?.map(convertServerArgument),
+                    runtimeHint: p.runtime_hint,
+                    runtimeArguments: p.runtime_arguments?.map(convertServerArgument),
+                    environmentVariables: p.environment_variables?.map(convertKeyValueInput),
+                })),
+                remotes: from.remotes?.map(remote => {
+                    const type = remote.type ?? remote.transport_type ?? remote.transport;
+                    return {
+                        type: type === TransportType.SSE ? TransportType.SSE : TransportType.STREAMABLE_HTTP,
+                        url: remote.url,
+                        headers: remote.headers?.map(convertKeyValueInput)
+                    };
+                }),
+                registryInfo: {
+                    id: from.id,
+                    isLatest: true,
+                    updatedAt: from.updated_at,
+                },
+            };
+        }
+    }
+    McpServer1ESSchema.SERIALIZER = ( new Serializer());
+})(McpServer1ESSchema || (McpServer1ESSchema = {}));
+var McpServerSchemaVersion_2025_01_09;
+(function (McpServerSchemaVersion_2025_01_09) {
+    McpServerSchemaVersion_2025_01_09.VERSION = '2025-09-01';
+    McpServerSchemaVersion_2025_01_09.SCHEMA = `https://static.modelcontextprotocol.io/schemas/${McpServerSchemaVersion_2025_01_09.VERSION}/server.schema.json`;
+    class Serializer {
+        toRawGalleryMcpServerResult(input) {
+            if (!input || !Array.isArray(input.servers)) {
+                return undefined;
+            }
+            const from = input;
+            const servers = [];
+            for (const server of from.servers) {
+                const rawServer = this.toRawGalleryMcpServer(server);
+                if (!rawServer) {
+                    return undefined;
+                }
+                servers.push(rawServer);
+            }
+            return {
+                metadata: from.metadata,
+                servers
+            };
+        }
+        toRawGalleryMcpServer(input) {
+            if (!input || input.$schema !== McpServerSchemaVersion_2025_01_09.SCHEMA) {
+                return undefined;
+            }
+            const from = input;
+            const registryInfo = from._meta?.['io.modelcontextprotocol.registry'];
+            function convertServerInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                };
+            }
+            function convertVariables(variables) {
+                const result = {};
+                for (const [key, value] of Object.entries(variables)) {
+                    result[key] = convertServerInput(value);
+                }
+                return result;
+            }
+            function convertServerArgument(arg) {
+                if (arg.type === 'positional') {
+                    return {
+                        ...arg,
+                        valueHint: arg.value_hint,
+                        isRepeated: arg.is_repeated,
+                        isRequired: arg.is_required,
+                        isSecret: arg.is_secret,
+                        variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                    };
+                }
+                return {
+                    ...arg,
+                    isRepeated: arg.is_repeated,
+                    isRequired: arg.is_required,
+                    isSecret: arg.is_secret,
+                    variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                };
+            }
+            function convertKeyValueInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                    variables: input.variables ? convertVariables(input.variables) : undefined,
+                };
+            }
+            function convertTransport(input) {
+                switch (input.type) {
+                    case 'stdio':
+                        return {
+                            type: TransportType.STDIO,
+                        };
+                    case 'streamable-http':
+                        return {
+                            type: TransportType.STREAMABLE_HTTP,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    case 'sse':
+                        return {
+                            type: TransportType.SSE,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    default:
+                        return undefined;
+                }
+            }
+            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;
+                }
+            }
+            return {
+                name: from.name,
+                description: from.description,
+                repository: from.repository ? {
+                    url: from.repository.url,
+                    source: from.repository.source,
+                    id: from.repository.id,
+                    readme: from.repository.readme
+                } : undefined,
+                version: from.version_detail.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) : undefined,
+                    packageArguments: p.package_arguments?.map(convertServerArgument),
+                    runtimeHint: p.runtime_hint,
+                    runtimeArguments: p.runtime_arguments?.map(convertServerArgument),
+                    environmentVariables: p.environment_variables?.map(convertKeyValueInput),
+                })),
+                remotes: from.remotes?.map(remote => {
+                    const type = remote.type ?? remote.transport_type ?? remote.transport;
+                    return {
+                        type: type === TransportType.SSE ? TransportType.SSE : TransportType.STREAMABLE_HTTP,
+                        url: remote.url,
+                        headers: remote.headers?.map(convertKeyValueInput)
+                    };
+                }),
+                registryInfo: {
+                    id: registryInfo.id,
+                    isLatest: registryInfo.is_latest,
+                    publishedAt: registryInfo.published_at,
+                    updatedAt: registryInfo.updated_at,
+                },
+                githubInfo: from._meta.github,
+            };
+        }
+    }
+    McpServerSchemaVersion_2025_01_09.SERIALIZER = ( new Serializer());
+})(McpServerSchemaVersion_2025_01_09 || (McpServerSchemaVersion_2025_01_09 = {}));
+var McpServerSchemaVersion_2025_07_09;
+(function (McpServerSchemaVersion_2025_07_09) {
+    McpServerSchemaVersion_2025_07_09.VERSION = '2025-07-09';
+    McpServerSchemaVersion_2025_07_09.SCHEMA = `https://static.modelcontextprotocol.io/schemas/${McpServerSchemaVersion_2025_07_09.VERSION}/server.schema.json`;
+    class Serializer {
+        toRawGalleryMcpServerResult(input) {
+            if (!input || !Array.isArray(input.servers)) {
+                return undefined;
+            }
+            const from = input;
+            const servers = [];
+            for (const server of from.servers) {
+                const rawServer = this.toRawGalleryMcpServer(server);
+                if (!rawServer) {
+                    return undefined;
+                }
+                servers.push(rawServer);
+            }
+            return {
+                metadata: from.metadata,
+                servers
+            };
+        }
+        toRawGalleryMcpServer(input) {
+            if (!input || input.$schema !== McpServerSchemaVersion_2025_07_09.SCHEMA) {
+                return undefined;
+            }
+            const from = input;
+            const registryInfo = from._meta?.['io.modelcontextprotocol.registry/official'];
+            function convertServerInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                };
+            }
+            function convertVariables(variables) {
+                const result = {};
+                for (const [key, value] of Object.entries(variables)) {
+                    result[key] = convertServerInput(value);
+                }
+                return result;
+            }
+            function convertServerArgument(arg) {
+                if (arg.type === 'positional') {
+                    return {
+                        ...arg,
+                        valueHint: arg.value_hint,
+                        isRepeated: arg.is_repeated,
+                        isRequired: arg.is_required,
+                        isSecret: arg.is_secret,
+                        variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                    };
+                }
+                return {
+                    ...arg,
+                    isRepeated: arg.is_repeated,
+                    isRequired: arg.is_required,
+                    isSecret: arg.is_secret,
+                    variables: arg.variables ? convertVariables(arg.variables) : undefined,
+                };
+            }
+            function convertKeyValueInput(input) {
+                return {
+                    ...input,
+                    isRequired: input.is_required,
+                    isSecret: input.is_secret,
+                    variables: input.variables ? convertVariables(input.variables) : undefined,
+                };
+            }
+            function convertTransport(input) {
+                switch (input.type) {
+                    case 'stdio':
+                        return {
+                            type: TransportType.STDIO,
+                        };
+                    case 'streamable-http':
+                        return {
+                            type: TransportType.STREAMABLE_HTTP,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    case 'sse':
+                        return {
+                            type: TransportType.SSE,
+                            url: input.url,
+                            headers: input.headers?.map(convertKeyValueInput),
+                        };
+                    default:
+                        return undefined;
+                }
+            }
+            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;
+                }
+            }
+            return {
+                name: from.name,
+                description: from.description,
+                repository: from.repository ? {
+                    url: from.repository.url,
+                    source: from.repository.source,
+                    id: from.repository.id,
+                    readme: from.repository.readme
+                } : undefined,
+                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) : undefined,
+                    packageArguments: p.package_arguments?.map(convertServerArgument),
+                    runtimeHint: p.runtime_hint,
+                    runtimeArguments: p.runtime_arguments?.map(convertServerArgument),
+                    environmentVariables: p.environment_variables?.map(convertKeyValueInput),
+                })),
+                remotes: from.remotes?.map(remote => {
+                    const type = remote.type ?? remote.transport_type ?? remote.transport;
+                    return {
+                        type: type === TransportType.SSE ? TransportType.SSE : TransportType.STREAMABLE_HTTP,
+                        url: remote.url,
+                        headers: remote.headers?.map(convertKeyValueInput)
+                    };
+                }),
+                registryInfo: {
+                    id: registryInfo.id,
+                    isLatest: registryInfo.is_latest,
+                    publishedAt: registryInfo.published_at,
+                    updatedAt: registryInfo.updated_at,
+                },
+                githubInfo: from._meta['io.modelcontextprotocol.registry/publisher-provided']?.github,
+            };
+        }
+    }
+    McpServerSchemaVersion_2025_07_09.SERIALIZER = ( new Serializer());
+})(McpServerSchemaVersion_2025_07_09 || (McpServerSchemaVersion_2025_07_09 = {}));
+var McpServerSchemaVersion_2025_16_09;
+(function (McpServerSchemaVersion_2025_16_09) {
+    McpServerSchemaVersion_2025_16_09.VERSION = '2025-16-09';
+    McpServerSchemaVersion_2025_16_09.SCHEMA = `https://static.modelcontextprotocol.io/schemas/${McpServerSchemaVersion_2025_16_09.VERSION}/server.schema.json`;
+    class Serializer {
+        toRawGalleryMcpServerResult(input) {
+            if (!input || !Array.isArray(input.servers)) {
+                return undefined;
+            }
+            const from = input;
+            const servers = [];
+            for (const server of from.servers) {
+                const rawServer = this.toRawGalleryMcpServer(server);
+                if (!rawServer) {
+                    return undefined;
+                }
+                servers.push(rawServer);
+            }
+            return {
+                metadata: from.metadata,
+                servers
+            };
+        }
+        toRawGalleryMcpServer(input) {
+            if (!input || input.$schema !== McpServerSchemaVersion_2025_16_09.SCHEMA) {
+                return undefined;
+            }
+            const from = input;
+            return {
+                name: from.name,
+                description: from.description,
+                repository: from.repository ? {
+                    url: from.repository.url,
+                    source: from.repository.source,
+                    id: from.repository.id,
+                    readme: from.repository.readme
+                } : undefined,
+                version: from.version,
+                status: from.status,
+                websiteUrl: from.websiteUrl,
+                createdAt: from.createdAt,
+                updatedAt: from.updatedAt,
+                packages: from.packages,
+                remotes: from.remotes,
+                registryInfo: from._meta?.['io.modelcontextprotocol.registry/official'],
+                githubInfo: from._meta['io.modelcontextprotocol.registry/publisher-provided']?.github,
+            };
+        }
+    }
+    McpServerSchemaVersion_2025_16_09.SERIALIZER = ( new Serializer());
+})(McpServerSchemaVersion_2025_16_09 || (McpServerSchemaVersion_2025_16_09 = {}));
 const DefaultPageSize = 50;
 const DefaultQueryState = {
     pageSize: DefaultPageSize,
@@ -35,6 +688,7 @@ class Query {
     }
     get pageSize() { return this.state.pageSize; }
     get searchText() { return this.state.searchText; }
+    get cursor() { return this.state.cursor; }
     withPage(cursor, pageSize = this.pageSize) {
         return ( new Query({ ...this.state, pageSize, cursor }));
     }
@@ -43,13 +697,18 @@ class Query {
     }
 }
 let McpGalleryService = class McpGalleryService extends Disposable {
-    constructor(requestService, fileService, productService, logService, mcpGalleryManifestService) {
+    constructor(requestService, fileService, logService, mcpGalleryManifestService) {
         super();
         this.requestService = requestService;
         this.fileService = fileService;
-        this.productService = productService;
         this.logService = logService;
         this.mcpGalleryManifestService = mcpGalleryManifestService;
+        this.galleryMcpServerDataSerializers = ( new Map());
+        this.galleryMcpServerDataSerializers.set(McpServerSchemaVersion_2025_07_09.VERSION, McpServerSchemaVersion_2025_07_09.SERIALIZER);
+        this.galleryMcpServerDataSerializers.set(McpServerSchemaVersion_2025_01_09.VERSION, McpServerSchemaVersion_2025_01_09.SERIALIZER);
+        this.galleryMcpServerDataSerializers.set('old', McpServerOldSchema.SERIALIZER);
+        this.galleryMcpServerDataSerializers.set('1es', McpServer1ESSchema.SERIALIZER);
+        this.galleryMcpServerDataSerializers.set(McpServerSchemaVersion_2025_16_09.VERSION, McpServerSchemaVersion_2025_16_09.SERIALIZER);
     }
     isEnabled() {
         return this.mcpGalleryManifestService.mcpGalleryManifestStatus === McpGalleryManifestStatus.Available;
@@ -59,14 +718,17 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         if (!mcpGalleryManifest) {
             return singlePagePager([]);
         }
-        const query = ( new Query());
+        let query = ( new Query());
+        if (options?.text) {
+            query = query.withSearchText(options.text.trim());
+        }
         const { servers, metadata } = await this.queryGalleryMcpServers(query, mcpGalleryManifest, token);
         const total = metadata?.total ?? metadata?.count ?? servers.length;
         const getNextPage = async (cursor, ct) => {
             if (ct.isCancellationRequested) {
                 throw ( new CancellationError());
             }
-            const { servers, metadata } = cursor ? await this.queryGalleryMcpServers(query.withPage(cursor), mcpGalleryManifest, token) : { servers: [], metadata: undefined };
+            const { servers, metadata } = cursor ? await this.queryGalleryMcpServers(query.withPage(cursor).withSearchText(undefined), mcpGalleryManifest, token) : { servers: [], metadata: undefined };
             return {
                 elements: servers,
                 total,
@@ -99,10 +761,6 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         })));
         return mcpServers;
     }
-    async getMcpServersFromVSCodeGallery(names) {
-        const servers = await this.fetchMcpServersFromVSCodeGallery();
-        return servers.filter(item => names.includes(item.name));
-    }
     async getMcpServerConfiguration(gallery, token) {
         if (gallery.configuration) {
             return gallery.configuration;
@@ -118,7 +776,10 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         if (!result) {
             throw ( new Error(`Failed to fetch configuration from ${gallery.url}`));
         }
-        const server = this.toIRawGalleryMcpServer(result);
+        const server = this.serializeMcpServer(result);
+        if (!server) {
+            throw ( new Error(`Failed to serialize MCP server data from ${gallery.url}`, result));
+        }
         const configuration = this.toGalleryMcpServerConfiguration(server.packages, server.remotes);
         if (!configuration) {
             throw ( new Error(`Failed to fetch configuration for ${gallery.url}`));
@@ -128,7 +789,7 @@ let McpGalleryService = class McpGalleryService extends Disposable {
     async getReadme(gallery, token) {
         const readmeUrl = gallery.readmeUrl;
         if (!readmeUrl) {
-            return Promise.resolve(( localize(1971, 'No README available')));
+            return Promise.resolve(( localize(1973, 'No README available')));
         }
         const uri = ( URI.parse(readmeUrl));
         if (uri.scheme === Schemas.file) {
@@ -141,7 +802,7 @@ let McpGalleryService = class McpGalleryService extends Disposable {
             }
         }
         if (uri.authority !== 'raw.githubusercontent.com') {
-            return ( new MarkdownString(( localize(1972, "You can find information about this server [here]({0})", readmeUrl)))).value;
+            return ( new MarkdownString(( localize(1974, "You can find information about this server [here]({0})", readmeUrl)))).value;
         }
         const context = await this.requestService.request({
             type: 'GET',
@@ -153,14 +814,14 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         }
         return result;
     }
-    toGalleryMcpServer(server, serverUrl) {
-        const registryInfo = server._meta?.['x-io.modelcontextprotocol.registry'];
-        const githubInfo = server._meta?.['github'] ?? server._meta?.['x-github'];
+    toGalleryMcpServer(server, manifest) {
         let publisher = '';
         let displayName = '';
-        if (githubInfo?.name) {
-            displayName = ( githubInfo.name.split('-').map(s => uppercaseFirstLetter(s))).join(' ');
-            publisher = githubInfo.name_with_owner.split('/')[0];
+        if (server.githubInfo?.name) {
+            displayName = ( server.githubInfo.name.split('-').map(
+                s => s.toLowerCase() === 'mcp' ? 'MCP' : s.toLowerCase() === 'github' ? 'GitHub' : uppercaseFirstLetter(s)
+            )).join(' ');
+            publisher = server.githubInfo.name_with_owner.split('/')[0];
         }
         else {
             const nameParts = server.name.split('/');
@@ -172,29 +833,36 @@ let McpGalleryService = class McpGalleryService extends Disposable {
             }
             displayName = ( nameParts[nameParts.length - 1].split('-').map(s => uppercaseFirstLetter(s))).join(' ');
         }
-        const icon = githubInfo?.owner_avatar_url ? {
-            light: githubInfo.owner_avatar_url,
-            dark: githubInfo.owner_avatar_url
+        if (server.githubInfo?.display_name) {
+            displayName = server.githubInfo.display_name;
+        }
+        const icon = server.githubInfo?.owner_avatar_url ? {
+            light: server.githubInfo.owner_avatar_url,
+            dark: server.githubInfo.owner_avatar_url
         } : undefined;
+        const serverUrl = manifest ? this.getServerUrl(server.registryInfo.id, manifest) : undefined;
+        const webUrl = manifest ? this.getWebUrl(server.name, manifest) : undefined;
+        const publisherUrl = manifest ? this.getPublisherUrl(publisher, manifest) : undefined;
         return {
-            id: server.id,
+            id: server.registryInfo.id,
             name: server.name,
             displayName,
             url: serverUrl,
+            webUrl,
             description: server.description,
             status: server.status ?? GalleryMcpServerStatus.Active,
-            version: server.version_detail.version,
-            isLatest: server.version_detail.is_latest,
-            releaseDate: Date.parse(server.version_detail.release_date),
-            publishDate: registryInfo ? Date.parse(registryInfo.published_at) : undefined,
-            lastUpdated: registryInfo ? Date.parse(registryInfo.updated_at) : undefined,
+            version: server.version,
+            isLatest: server.registryInfo.isLatest,
+            publishDate: server.registryInfo.publishedAt ? Date.parse(server.registryInfo.publishedAt) : undefined,
+            lastUpdated: server.githubInfo?.pushed_at ? Date.parse(server.githubInfo.pushed_at) : server.registryInfo ? Date.parse(server.registryInfo.updatedAt) : undefined,
             repositoryUrl: server.repository?.url,
             readme: server.repository?.readme,
             icon,
             publisher,
-            license: githubInfo?.license,
-            starsCount: githubInfo?.stargazer_count,
-            topics: githubInfo?.topics,
+            publisherUrl,
+            license: server.githubInfo?.license,
+            starsCount: server.githubInfo?.stargazer_count,
+            topics: server.githubInfo?.topics,
             configuration: this.toGalleryMcpServerConfiguration(server.packages, server.remotes)
         };
     }
@@ -203,30 +871,19 @@ let McpGalleryService = class McpGalleryService extends Disposable {
             return undefined;
         }
         return {
-            packages: packages?.map(p => ({
-                ...p,
-                identifier: p.identifier ?? p.name,
-                registry_type: p.registry_type ?? p.registry_name
-            })),
+            packages,
             remotes
         };
     }
     async queryGalleryMcpServers(query, mcpGalleryManifest, token) {
-        if (mcpGalleryManifest.url === this.productService.extensionsGallery?.mcpUrl) {
-            return {
-                servers: await this.fetchMcpServersFromVSCodeGallery()
-            };
-        }
         const { servers, metadata } = await this.queryRawGalleryMcpServers(query, mcpGalleryManifest, token);
         return {
-            servers: ( servers.map(
-                item => this.toGalleryMcpServer(item, this.getServerUrl(item.id, mcpGalleryManifest))
-            )),
+            servers: ( servers.map(item => this.toGalleryMcpServer(item, mcpGalleryManifest))),
             metadata
         };
     }
     async queryRawGalleryMcpServers(query, mcpGalleryManifest, token) {
-        const mcpGalleryUrl = this.getMcpGalleryUrl(mcpGalleryManifest);
+        const mcpGalleryUrl = query.searchText ? this.getSearchUrl(mcpGalleryManifest) : this.getMcpGalleryUrl(mcpGalleryManifest);
         if (!mcpGalleryUrl) {
             return { servers: [] };
         }
@@ -241,24 +898,29 @@ let McpGalleryService = class McpGalleryService extends Disposable {
                 this.logService.error(`Failed to read file from ${uri}: ${error}`);
             }
         }
-        const url = `${mcpGalleryUrl}?limit=${query.pageSize}`;
+        let url = `${mcpGalleryUrl}?limit=${query.pageSize}`;
+        if (query.cursor) {
+            url += `&cursor=${query.cursor}`;
+        }
+        if (query.searchText) {
+            const text = encodeURIComponent(query.searchText);
+            url += `&q=${text}`;
+        }
         const context = await this.requestService.request({
             type: 'GET',
             url,
         }, token);
-        const result = await asJson(context);
-        if (!result) {
+        const data = await asJson(context);
+        if (!data) {
             return { servers: [] };
         }
-        if (isIRawGalleryServersOldResult(result)) {
-            return {
-                servers: ( result.servers.map(server => this.toIRawGalleryMcpServer(server))),
-                metadata: result.metadata
-            };
+        const result = this.serializeMcpServersResult(data);
+        if (!result) {
+            throw ( new Error(`Failed to serialize MCP servers result from ${mcpGalleryUrl}`, data));
         }
         return result;
     }
-    async getMcpServer(mcpServerUrl) {
+    async getMcpServer(mcpServerUrl, mcpGalleryManifest) {
         const context = await this.requestService.request({
             type: 'GET',
             url: mcpServerUrl,
@@ -266,77 +928,106 @@ let McpGalleryService = class McpGalleryService extends Disposable {
         if (context.res.statusCode && context.res.statusCode >= 400 && context.res.statusCode < 500) {
             return undefined;
         }
-        const server = await asJson(context);
-        if (!server) {
+        const data = await asJson(context);
+        if (!data) {
             return undefined;
         }
-        return this.toGalleryMcpServer(this.toIRawGalleryMcpServer(server), mcpServerUrl);
-    }
-    toIRawGalleryMcpServer(from) {
-        if (isIRawGalleryOldMcpServer(from)) {
-            return {
-                ...from.server,
-                _meta: {
-                    'x-io.modelcontextprotocol.registry': from['x-io.modelcontextprotocol.registry'],
-                    'github': from['x-github'],
-                    'x-publisher': from['x-publisher']
-                }
-            };
+        const server = this.serializeMcpServer(data);
+        if (!server) {
+            throw ( new Error(`Failed to serialize MCP server from ${mcpServerUrl}`, data));
+        }
+        if (!mcpGalleryManifest) {
+            mcpGalleryManifest = await this.mcpGalleryManifestService.getMcpGalleryManifest();
+            if (mcpGalleryManifest && mcpServerUrl !== this.getServerUrl(basename(mcpServerUrl), mcpGalleryManifest)) {
+                mcpGalleryManifest = null;
+            }
         }
-        return from;
+        return this.toGalleryMcpServer(server, mcpGalleryManifest);
     }
-    async fetchMcpServersFromVSCodeGallery() {
-        const mcpGalleryUrl = this.productService.extensionsGallery?.mcpUrl;
-        if (!mcpGalleryUrl) {
-            return [];
+    async getMcpServerByName(name) {
+        const mcpGalleryManifest = await this.mcpGalleryManifestService.getMcpGalleryManifest();
+        if (!mcpGalleryManifest) {
+            return undefined;
+        }
+        const mcpServerUrl = this.getNamedServerUrl(name, mcpGalleryManifest);
+        if (!mcpServerUrl) {
+            return undefined;
         }
         const context = await this.requestService.request({
             type: 'GET',
-            url: mcpGalleryUrl,
+            url: mcpServerUrl,
         }, CancellationToken.None);
-        const result = await asJson(context);
-        if (!result) {
-            return [];
+        if (context.res.statusCode && context.res.statusCode >= 400 && context.res.statusCode < 500) {
+            return undefined;
         }
-        return ( result.servers.map(item => {
-            return {
-                id: item.name,
-                name: item.name,
-                displayName: item.displayName,
-                description: item.description,
-                version: '0.0.1',
-                isLatest: true,
-                status: GalleryMcpServerStatus.Active,
-                repositoryUrl: item.repository?.url,
-                codicon: item.codicon,
-                publisher: '',
-                publisherDisplayName: item.publisher?.displayName,
-                publisherDomain: item.publisher ? {
-                    link: item.publisher.url,
-                    verified: item.publisher.is_verified,
-                } : undefined,
-                readmeUrl: item.readmeUrl,
-                configuration: this.toGalleryMcpServerConfiguration(item.manifest.packages, item.manifest.remotes)
-            };
-        }));
+        const data = await asJson(context);
+        if (!data) {
+            return undefined;
+        }
+        const server = this.serializeMcpServer(data);
+        if (!server) {
+            throw ( new Error(`Failed to serialize MCP server from ${mcpServerUrl}`, data));
+        }
+        return this.toGalleryMcpServer(server, mcpGalleryManifest);
+    }
+    serializeMcpServer(data) {
+        for (const [, serializer] of this.galleryMcpServerDataSerializers) {
+            const result = serializer.toRawGalleryMcpServer(data);
+            if (result) {
+                return result;
+            }
+        }
+        return undefined;
+    }
+    serializeMcpServersResult(data) {
+        for (const [, serializer] of this.galleryMcpServerDataSerializers) {
+            const result = serializer.toRawGalleryMcpServerResult(data);
+            if (result) {
+                return result;
+            }
+        }
+        return undefined;
     }
     getServerUrl(id, mcpGalleryManifest) {
-        const resourceUriTemplate = getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpServerManifestUri);
+        const resourceUriTemplate = getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpServerResourceUri);
         if (!resourceUriTemplate) {
             return undefined;
         }
         return format2(resourceUriTemplate, { id });
     }
+    getNamedServerUrl(name, mcpGalleryManifest) {
+        const namedResourceUriTemplate = getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpServerNamedResourceUri);
+        if (!namedResourceUriTemplate) {
+            return undefined;
+        }
+        return format2(namedResourceUriTemplate, { name });
+    }
+    getSearchUrl(mcpGalleryManifest) {
+        return getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpServersSearchService);
+    }
+    getWebUrl(name, mcpGalleryManifest) {
+        const resourceUriTemplate = getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpServerWebUri);
+        if (!resourceUriTemplate) {
+            return undefined;
+        }
+        return format2(resourceUriTemplate, { name });
+    }
+    getPublisherUrl(name, mcpGalleryManifest) {
+        const resourceUriTemplate = getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.PublisherUriTemplate);
+        if (!resourceUriTemplate) {
+            return undefined;
+        }
+        return format2(resourceUriTemplate, { name });
+    }
     getMcpGalleryUrl(mcpGalleryManifest) {
-        return getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpQueryService);
+        return getMcpGalleryManifestResourceUri(mcpGalleryManifest, McpGalleryResourceType.McpServersQueryService);
     }
 };
 McpGalleryService = ( __decorate([
     ( __param(0, IRequestService)),
     ( __param(1, IFileService)),
-    ( __param(2, IProductService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IMcpGalleryManifestService))
+    ( __param(2, ILogService)),
+    ( __param(3, IMcpGalleryManifestService))
 ], McpGalleryService));
 
 export { McpGalleryService };