@theia/plugin-ext 1.63.0-next.24 → 1.63.0-next.52

package/src/common/lm-protocol.ts

@@ -0,0 +1,137 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { UriComponents } from './uri-components';
+
+/**
+ * Protocol interfaces for MCP server definition providers.
+ */
+
+export interface McpStdioServerDefinitionDto {
+    /**
+     * The human-readable name of the server.
+     */
+    readonly label: string;
+
+    /**
+     * The working directory used to start the server.
+     */
+    cwd?: UriComponents;
+
+    /**
+     * The command used to start the server. Node.js-based servers may use
+     * `process.execPath` to use the editor's version of Node.js to run the script.
+     */
+    command: string;
+
+    /**
+     * Additional command-line arguments passed to the server.
+     */
+    args?: string[];
+
+    /**
+     * Optional additional environment information for the server. Variables
+     * in this environment will overwrite or remove (if null) the default
+     * environment variables of the editor's extension host.
+     */
+    env?: Record<string, string | number | null>;
+
+    /**
+     * Optional version identification for the server. If this changes, the
+     * editor will indicate that tools have changed and prompt to refresh them.
+     */
+    version?: string;
+
+}
+
+/**
+ * McpHttpServerDefinition represents an MCP server available using the
+ * Streamable HTTP transport.
+ */
+export interface McpHttpServerDefinitionDto {
+    /**
+     * The human-readable name of the server.
+     */
+    readonly label: string;
+
+    /**
+     * The URI of the server. The editor will make a POST request to this URI
+     * to begin each session.
+     */
+    uri: UriComponents;
+
+    /**
+     * Optional additional heads included with each request to the server.
+     */
+    headers?: Record<string, string>;
+
+    /**
+     * Optional version identification for the server. If this changes, the
+     * editor will indicate that tools have changed and prompt to refresh them.
+     */
+    version?: string;
+}
+
+/**
+ * Definitions that describe different types of Model Context Protocol servers,
+ * which can be returned from the {@link McpServerDefinitionProvider}.
+ */
+export type McpServerDefinitionDto = McpStdioServerDefinitionDto | McpHttpServerDefinitionDto;
+export const isMcpHttpServerDefinitionDto = (definition: McpServerDefinitionDto): definition is McpHttpServerDefinitionDto => 'uri' in definition;
+/**
+ * Main side of the MCP server definition registry.
+ */
+export interface McpServerDefinitionRegistryMain {
+    /**
+     * Register an MCP server definition provider.
+     */
+    $registerMcpServerDefinitionProvider(handle: number, name: string): void;
+
+    /**
+     * Unregister an MCP server definition provider.
+     */
+    $unregisterMcpServerDefinitionProvider(handle: number): void;
+
+    /**
+     * Notify that server definitions have changed.
+     */
+    $onDidChangeMcpServerDefinitions(handle: number): void;
+
+    /**
+     * Get server definitions from a provider.
+     */
+    $getServerDefinitions(handle: number): Promise<McpServerDefinitionDto[]>;
+
+    /**
+     * Resolve a server definition.
+     */
+    $resolveServerDefinition(handle: number, server: McpServerDefinitionDto): Promise<McpServerDefinitionDto | undefined>;
+}
+
+/**
+ * Extension side of the MCP server definition registry.
+ */
+export interface McpServerDefinitionRegistryExt {
+    /**
+     * Request server definitions from a provider.
+     */
+    $provideServerDefinitions(handle: number): Promise<McpServerDefinitionDto[]>;
+
+    /**
+     * Resolve a server definition from a provider.
+     */
+    $resolveServerDefinition(handle: number, server: McpServerDefinitionDto): Promise<McpServerDefinitionDto | undefined>;
+}

package/src/common/plugin-api-rpc.ts

@@ -127,6 +127,7 @@ import { AccessibilityInformation } from '@theia/core/lib/common/accessibility';
 import { TreeDelta } from '@theia/test/lib/common/tree-delta';
 import { TestItemDTO, TestOutputDTO, TestRunDTO, TestRunProfileDTO, TestRunRequestDTO, TestStateChangeDTO } from './test-types';
 import { ArgumentProcessor } from './commands';
+import { McpServerDefinitionRegistryMain, McpServerDefinitionRegistryExt } from './lm-protocol';
 
 export interface PreferenceData {
     [scope: number]: any;
@@ -2346,7 +2347,8 @@ export const PLUGIN_RPC_CONTEXT = {
     TELEMETRY_MAIN: createProxyIdentifier<TelemetryMain>('TelemetryMain'),
     LOCALIZATION_MAIN: createProxyIdentifier<LocalizationMain>('LocalizationMain'),
     TESTING_MAIN: createProxyIdentifier<TestingMain>('TestingMain'),
-    URI_MAIN: createProxyIdentifier<UriMain>('UriMain')
+    URI_MAIN: createProxyIdentifier<UriMain>('UriMain'),
+    MCP_SERVER_DEFINITION_REGISTRY_MAIN: createProxyIdentifier<McpServerDefinitionRegistryMain>('McpServerDefinitionRegistryMain')
 };
 
 export const MAIN_RPC_CONTEXT = {
@@ -2389,7 +2391,8 @@ export const MAIN_RPC_CONTEXT = {
     TABS_EXT: createProxyIdentifier<TabsExt>('TabsExt'),
     TELEMETRY_EXT: createProxyIdentifier<TelemetryExt>('TelemetryExt)'),
     TESTING_EXT: createProxyIdentifier<TestingExt>('TestingExt'),
-    URI_EXT: createProxyIdentifier<UriExt>('UriExt')
+    URI_EXT: createProxyIdentifier<UriExt>('UriExt'),
+    MCP_SERVER_DEFINITION_REGISTRY_EXT: createProxyIdentifier<McpServerDefinitionRegistryExt>('McpServerDefinitionRegistryExt')
 };
 
 export interface TasksExt {

package/src/common/plugin-protocol.ts

@@ -104,6 +104,7 @@ export interface PluginPackageContribution {
     notebooks?: PluginPackageNotebook[];
     notebookRenderer?: PluginNotebookRendererContribution[];
     notebookPreload?: PluginPackageNotebookPreload[];
+    mcpServerDefinitionProviders?: PluginPackageMcpServerDefinitionProviderContribution[];
 }
 
 export interface PluginPackageNotebook {
@@ -126,6 +127,12 @@ export interface PluginPackageNotebookPreload {
     entrypoint: string;
 }
 
+export interface PluginPackageMcpServerDefinitionProviderContribution {
+    id: string;
+    label: string;
+    description?: string;
+}
+
 export interface PluginPackageAuthenticationProvider {
     id: string;
     label: string;

package/src/hosted/node/plugin-host-module.ts

@@ -36,6 +36,7 @@ import { WebviewsExtImpl } from '../../plugin/webviews';
 import { TerminalServiceExtImpl } from '../../plugin/terminal-ext';
 import { InternalSecretsExt, SecretsExtImpl } from '../../plugin/secrets-ext';
 import { setupPluginHostLogger } from './plugin-host-logger';
+import { LmExtImpl } from '../../plugin/lm-ext';
 
 export default new ContainerModule(bind => {
     const channel = new IPCChannel();
@@ -63,6 +64,7 @@ export default new ContainerModule(bind => {
     bind(SecretsExtImpl).toSelf().inSingletonScope();
     bind(PreferenceRegistryExtImpl).toSelf().inSingletonScope();
     bind(DebugExtImpl).toSelf().inSingletonScope();
+    bind(LmExtImpl).toSelf().inSingletonScope();
     bind(EditorsAndDocumentsExtImpl).toSelf().inSingletonScope();
     bind(WorkspaceExtImpl).toSelf().inSingletonScope();
     bind(MessageRegistryExt).toSelf().inSingletonScope();

package/src/main/browser/lm-main.ts

@@ -0,0 +1,136 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { interfaces } from '@theia/core/shared/inversify';
+import { RPCProtocol } from '../../common/rpc-protocol';
+import {
+    McpServerDefinitionRegistryMain,
+    McpServerDefinitionRegistryExt,
+    McpServerDefinitionDto,
+    isMcpHttpServerDefinitionDto,
+} from '../../common/lm-protocol';
+import { MAIN_RPC_CONTEXT } from '../../common/plugin-api-rpc';
+import { MCPServerManager, MCPServerDescription } from '@theia/ai-mcp/lib/common';
+
+export class McpServerDefinitionRegistryMainImpl implements McpServerDefinitionRegistryMain {
+    private readonly proxy: McpServerDefinitionRegistryExt;
+    private readonly providers = new Map<number, string>();
+    private readonly mcpServerManager: MCPServerManager | undefined;
+
+    constructor(
+        rpc: RPCProtocol,
+        container: interfaces.Container
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.MCP_SERVER_DEFINITION_REGISTRY_EXT);
+        try {
+            this.mcpServerManager = container.get(MCPServerManager);
+        } catch {
+            // MCP Server Manager is optional
+            this.mcpServerManager = undefined;
+        }
+    }
+
+    $registerMcpServerDefinitionProvider(handle: number, name: string): void {
+        this.providers.set(handle, name);
+        this.loadServerDefinitions(handle);
+    }
+
+    $unregisterMcpServerDefinitionProvider(handle: number): void {
+        if (!this.mcpServerManager) {
+            console.warn('MCP Server Manager not available - MCP server definitions will not be loaded');
+            return;
+        }
+        const provider = this.providers.get(handle);
+        if (!provider) {
+            console.warn(`No MCP Server provider found for handle '${handle}' - MCP server definitions will not be loaded`);
+            return;
+        }
+        this.mcpServerManager.removeServer(provider);
+        this.providers.delete(handle);
+    }
+
+    $onDidChangeMcpServerDefinitions(handle: number): void {
+        // Reload server definitions when provider reports changes
+        this.loadServerDefinitions(handle);
+    }
+
+    async $getServerDefinitions(handle: number): Promise<McpServerDefinitionDto[]> {
+        try {
+            return await this.proxy.$provideServerDefinitions(handle);
+        } catch (error) {
+            console.error('Error getting MCP server definitions:', error);
+            return [];
+        }
+    }
+
+    async $resolveServerDefinition(handle: number, server: McpServerDefinitionDto): Promise<McpServerDefinitionDto | undefined> {
+        try {
+            return await this.proxy.$resolveServerDefinition(handle, server);
+        } catch (error) {
+            console.error('Error resolving MCP server definition:', error);
+            return server;
+        }
+    }
+
+    private async loadServerDefinitions(handle: number): Promise<void> {
+        if (!this.mcpServerManager) {
+            console.warn('MCP Server Manager not available - MCP server definitions will not be loaded');
+            return;
+        }
+
+        try {
+            const definitions = await this.$getServerDefinitions(handle);
+
+            for (const definition of definitions) {
+                const resolved = await this.$resolveServerDefinition(handle, definition);
+                if (resolved) {
+                    const mcpServerDescription = this.convertToMcpServerDescription(resolved);
+                    this.mcpServerManager.addOrUpdateServer(mcpServerDescription);
+                }
+            }
+        } catch (error) {
+            console.error('Error loading MCP server definitions:', error);
+        }
+    }
+
+    private convertToMcpServerDescription(definition: McpServerDefinitionDto): MCPServerDescription {
+        if (isMcpHttpServerDefinitionDto(definition)) {
+            // For HTTP servers, we would need to create a bridge or adapter
+            // For now, we'll create a placeholder stdio server that could proxy to HTTP
+            console.warn(`HTTP transport not yet supported for MCP server '${definition.label}'. Skipping.`);
+            throw new Error(`HTTP transport not yet supported for MCP server '${definition.label}'`);
+        }
+
+        // Convert env values to strings, filtering out null values
+        let convertedEnv: Record<string, string> | undefined;
+        if (definition.env) {
+            convertedEnv = {};
+            for (const [key, value] of Object.entries(definition.env)) {
+                if (value !== null) {
+                    convertedEnv[key] = String(value);
+                }
+            }
+        }
+
+        return {
+            name: definition.label,
+            command: definition.command!,
+            args: definition.args,
+            env: convertedEnv,
+            autostart: false, // Extensions should manage their own server lifecycle
+        };
+    }
+}

package/src/main/browser/main-context.ts

@@ -67,6 +67,7 @@ import { TestingMainImpl } from './test-main';
 import { UriMainImpl } from './uri-main';
 import { LoggerMainImpl } from './logger-main';
 import { MonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
+import { McpServerDefinitionRegistryMainImpl } from './lm-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const loggerMain = new LoggerMainImpl(container);
@@ -213,4 +214,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
     const uriMain = new UriMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.URI_MAIN, uriMain);
+
+    const mcpServerDefinitionRegistryMain = new McpServerDefinitionRegistryMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.MCP_SERVER_DEFINITION_REGISTRY_MAIN, mcpServerDefinitionRegistryMain);
 }

package/src/plugin/lm-ext.ts

@@ -0,0 +1,158 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import type * as theia from '@theia/plugin';
+import { Disposable } from '@theia/core/lib/common/disposable';
+import { RPCProtocol } from '../common/rpc-protocol';
+import {
+    McpServerDefinitionRegistryExt,
+    McpServerDefinitionRegistryMain,
+    McpServerDefinitionDto,
+    isMcpHttpServerDefinitionDto,
+} from '../common/lm-protocol';
+import { PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
+import { PluginPackageMcpServerDefinitionProviderContribution } from '../common';
+import { PluginLogger } from './logger';
+import { McpHttpServerDefinition, McpServerDefinition, URI } from './types-impl';
+
+// Local interfaces that match the proposed MCP API
+interface McpServerDefinitionProvider {
+    readonly onDidChangeMcpServerDefinitions?: theia.Event<void>;
+    provideMcpServerDefinitions(): theia.ProviderResult<McpServerDefinition[]>;
+    resolveMcpServerDefinition?(server: McpServerDefinition): theia.ProviderResult<McpServerDefinition>;
+}
+
+export class LmExtImpl implements McpServerDefinitionRegistryExt {
+
+    private proxy: McpServerDefinitionRegistryMain;
+    private logger: PluginLogger;
+    private readonly providers = new Map<number, McpServerDefinitionProvider>();
+    private readonly providerChangeListeners = new Map<number, Disposable>();
+    private handleCounter = 0;
+    private announcedMCPProviders: string[] = [];
+
+    constructor(protected readonly rpc: RPCProtocol) {
+        this.proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.MCP_SERVER_DEFINITION_REGISTRY_MAIN);
+        this.logger = new PluginLogger(this.rpc, 'lm');
+    }
+
+    registerMcpServerDefinitionProvider(id: string, provider: McpServerDefinitionProvider): theia.Disposable {
+        if (this.announcedMCPProviders.indexOf(id) === -1) {
+            this.logger.warn(`An unknown McpProvider tried to register, please check the package.json: ${id}`);
+        }
+        const handle = this.handleCounter++;
+        this.providers.set(handle, provider);
+
+        this.proxy.$registerMcpServerDefinitionProvider(handle, id);
+
+        if (provider.onDidChangeMcpServerDefinitions) {
+            const changeListener = provider.onDidChangeMcpServerDefinitions(() => {
+                this.proxy.$onDidChangeMcpServerDefinitions(handle);
+            });
+            this.providerChangeListeners.set(handle, changeListener);
+        }
+
+        return Disposable.create(() => {
+            this.providers.delete(handle);
+            const changeListener = this.providerChangeListeners.get(handle);
+            if (changeListener) {
+                changeListener.dispose();
+                this.providerChangeListeners.delete(handle);
+            }
+            this.proxy.$unregisterMcpServerDefinitionProvider(handle);
+        });
+    }
+
+    async $provideServerDefinitions(handle: number): Promise<McpServerDefinitionDto[]> {
+        const provider = this.providers.get(handle);
+        if (!provider) {
+            return [];
+        }
+
+        try {
+            const definitions = await provider.provideMcpServerDefinitions();
+            if (!definitions) {
+                return [];
+            }
+
+            return definitions.map(def => this.convertToDto(def));
+        } catch (error) {
+            this.logger.error('Error providing MCP server definitions:', error);
+            return [];
+        }
+    }
+
+    async $resolveServerDefinition(handle: number, server: McpServerDefinitionDto): Promise<McpServerDefinitionDto | undefined> {
+        const provider = this.providers.get(handle);
+        if (!provider || !provider.resolveMcpServerDefinition) {
+            return server;
+        }
+
+        try {
+            const definition = this.convertFromDto(server);
+            const resolved = await provider.resolveMcpServerDefinition(definition);
+            return resolved ? this.convertToDto(resolved) : undefined;
+        } catch (error) {
+            this.logger.error('Error resolving MCP server definition:', error);
+            return server;
+        }
+    }
+
+    private convertToDto(definition: McpServerDefinition): McpServerDefinitionDto {
+        if (isMcpHttpServerDefinition(definition)) {
+            return {
+                label: definition.label,
+                headers: definition.headers,
+                uri: definition.uri,
+                version: definition.version
+            };
+        }
+        return {
+            command: definition.command,
+            args: definition.args,
+            cwd: definition.cwd,
+            version: definition.version,
+            label: definition.label,
+            env: definition.env
+        };
+    }
+
+    private convertFromDto(dto: McpServerDefinitionDto): McpServerDefinition {
+        if (isMcpHttpServerDefinitionDto(dto)) {
+            return {
+                label: dto.label,
+                headers: dto.headers,
+                uri: URI.revive(dto.uri),
+                version: dto.version
+            };
+        }
+        return {
+            command: dto.command,
+            args: dto.args,
+            cwd: URI.revive(dto.cwd),
+            version: dto.version,
+            label: dto.label,
+            env: dto.env
+        };
+    }
+
+    registerMcpContributions(mcpContributions: PluginPackageMcpServerDefinitionProviderContribution[]): void {
+        this.announcedMCPProviders = mcpContributions.map(contribution => contribution.id);
+    }
+}
+
+const isMcpHttpServerDefinition = (definition: McpServerDefinition): definition is McpHttpServerDefinition => 'uri' in definition;
+

package/src/plugin/plugin-context.ts

@@ -238,7 +238,9 @@ import {
     DebugVisualization,
     TerminalShellExecutionCommandLineConfidence,
     TerminalCompletionItemKind,
-    TerminalCompletionList
+    TerminalCompletionList,
+    McpHttpServerDefinition,
+    McpStdioServerDefinition
 } from './types-impl';
 import { AuthenticationExtImpl } from './authentication-ext';
 import { SymbolKind } from '../common/plugin-api-rpc-model';
@@ -287,6 +289,7 @@ import { NotebookEditorsExtImpl } from './notebook/notebook-editors';
 import { TestingExtImpl } from './tests';
 import { UriExtImpl } from './uri-ext';
 import { PluginLogger } from './logger';
+import { LmExtImpl } from './lm-ext';
 
 export function createAPIObject<T extends Object>(rawObject: T): T {
     return new Proxy(rawObject, {
@@ -351,6 +354,7 @@ export function createAPIFactory(
     const telemetryExt = rpc.set(MAIN_RPC_CONTEXT.TELEMETRY_EXT, new TelemetryExtImpl());
     const testingExt = rpc.set(MAIN_RPC_CONTEXT.TESTING_EXT, new TestingExtImpl(rpc, commandRegistry));
     const uriExt = rpc.set(MAIN_RPC_CONTEXT.URI_EXT, new UriExtImpl(rpc));
+    const lmExt = rpc.set(MAIN_RPC_CONTEXT.MCP_SERVER_DEFINITION_REGISTRY_EXT, new LmExtImpl(rpc));
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
 
     const commandLogger = new PluginLogger(rpc, 'commands-plugin');
@@ -1342,6 +1346,9 @@ export function createAPIFactory(
             }
         };
 
+        const mcpContributions = plugin.rawModel.contributes && plugin.rawModel.contributes.mcpServerDefinitionProviders || [];
+        lmExt.registerMcpContributions(mcpContributions);
+
         const lm: typeof theia.lm = {
             /** @stubbed LanguageModelChat */
             selectChatModels(selector?: theia.LanguageModelChatSelector): Thenable<theia.LanguageModelChat[]> {
@@ -1358,7 +1365,10 @@ export function createAPIFactory(
                 return Disposable.NULL;
             },
             /** @stubbed LanguageModelTool */
-            tools: []
+            tools: [],
+            registerMcpServerDefinitionProvider(id: string, provider: any): theia.Disposable {
+                return lmExt.registerMcpServerDefinitionProvider(id, provider);
+            }
         };
 
         return <typeof theia>{
@@ -1589,7 +1599,9 @@ export function createAPIFactory(
             DebugVisualization,
             TerminalShellExecutionCommandLineConfidence,
             TerminalCompletionItemKind,
-            TerminalCompletionList
+            TerminalCompletionList,
+            McpHttpServerDefinition,
+            McpStdioServerDefinition
         };
     };
 }

package/src/plugin/types-impl.ts

@@ -4135,3 +4135,107 @@ export enum TerminalShellExecutionCommandLineConfidence {
 }
 
 // #endregion
+
+/**
+ * McpStdioServerDefinition represents an MCP server available by running
+ * a local process and operating on its stdin and stdout streams. The process
+ * will be spawned as a child process of the extension host and by default
+ * will not run in a shell environment.
+ */
+export class McpStdioServerDefinition {
+    /**
+     * The human-readable name of the server.
+     */
+    readonly label: string;
+
+    /**
+     * The working directory used to start the server.
+     */
+    cwd?: URI;
+
+    /**
+     * The command used to start the server. Node.js-based servers may use
+     * `process.execPath` to use the editor's version of Node.js to run the script.
+     */
+    command: string;
+
+    /**
+     * Additional command-line arguments passed to the server.
+     */
+    args?: string[];
+
+    /**
+     * Optional additional environment information for the server. Variables
+     * in this environment will overwrite or remove (if null) the default
+     * environment variables of the editor's extension host.
+     */
+    env?: Record<string, string | number | null>;
+
+    /**
+     * Optional version identification for the server. If this changes, the
+     * editor will indicate that tools have changed and prompt to refresh them.
+     */
+    version?: string;
+
+    /**
+     * @param label The human-readable name of the server.
+     * @param command The command used to start the server.
+     * @param args Additional command-line arguments passed to the server.
+     * @param env Optional additional environment information for the server.
+     * @param version Optional version identification for the server.
+     */
+    constructor(label: string, command: string, args?: string[], env?: Record<string, string | number | null>, version?: string) {
+        this.label = label;
+        this.command = command;
+        this.args = args;
+        this.env = env;
+        this.version = version;
+    }
+}
+
+/**
+ * McpHttpServerDefinition represents an MCP server available using the
+ * Streamable HTTP transport.
+ */
+export class McpHttpServerDefinition {
+    /**
+     * The human-readable name of the server.
+     */
+    readonly label: string;
+
+    /**
+     * The URI of the server. The editor will make a POST request to this URI
+     * to begin each session.
+     */
+    uri: URI;
+
+    /**
+     * Optional additional heads included with each request to the server.
+     */
+    headers?: Record<string, string>;
+
+    /**
+     * Optional version identification for the server. If this changes, the
+     * editor will indicate that tools have changed and prompt to refresh them.
+     */
+    version?: string;
+
+    /**
+     * @param label The human-readable name of the server.
+     * @param uri The URI of the server.
+     * @param headers Optional additional heads included with each request to the server.
+     */
+    constructor(label: string, uri: URI, headers?: Record<string, string>, version?: string) {
+        this.label = label;
+        this.uri = uri;
+        this.headers = headers;
+        this.version = version;
+    };
+}
+
+/**
+ * Definitions that describe different types of Model Context Protocol servers,
+ * which can be returned from the {@link McpServerDefinitionProvider}.
+ */
+export type McpServerDefinition = McpStdioServerDefinition | McpHttpServerDefinition;
+