@theia/ai-mcp 1.57.0-next.112

package/src/browser/mcp-command-contribution.ts

@@ -0,0 +1,106 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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 { AICommandHandlerFactory } from '@theia/ai-core/lib/browser/ai-command-handler-factory';
+import { CommandContribution, CommandRegistry, MessageService } from '@theia/core';
+import { QuickInputService } from '@theia/core/lib/browser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { MCPFrontendService } from './mcp-frontend-service';
+
+export const StartMCPServer = {
+    id: 'mcp.startserver',
+    label: 'MCP: Start MCP Server',
+};
+export const StopMCPServer = {
+    id: 'mcp.stopserver',
+    label: 'MCP: Stop MCP Server',
+};
+
+@injectable()
+export class MCPCommandContribution implements CommandContribution {
+    @inject(AICommandHandlerFactory)
+    protected readonly commandHandlerFactory: AICommandHandlerFactory;
+
+    @inject(QuickInputService)
+    protected readonly quickInputService: QuickInputService;
+
+    @inject(MessageService)
+    protected messageService: MessageService;
+
+    @inject(MCPFrontendService)
+    protected readonly mcpFrontendService: MCPFrontendService;
+
+    private async getMCPServerSelection(serverNames: string[]): Promise<string | undefined> {
+        if (!serverNames || serverNames.length === 0) {
+            return undefined;
+        }
+        const options = serverNames.map(mcpServerName => ({ label: mcpServerName }));
+        const result = await this.quickInputService.showQuickPick(options);
+        return result?.label;
+    }
+
+    registerCommands(commandRegistry: CommandRegistry): void {
+        commandRegistry.registerCommand(StopMCPServer, this.commandHandlerFactory({
+            execute: async () => {
+                try {
+                    const startedServers = await this.mcpFrontendService.getStartedServers();
+                    if (!startedServers || startedServers.length === 0) {
+                        this.messageService.error('No MCP servers running.');
+                        return;
+                    }
+                    const selection = await this.getMCPServerSelection(startedServers);
+                    if (!selection) {
+                        return;
+                    }
+                    await this.mcpFrontendService.stopServer(selection);
+                } catch (error) {
+                    console.error('Error while stopping MCP server:', error);
+                }
+            }
+        }));
+
+        commandRegistry.registerCommand(StartMCPServer, this.commandHandlerFactory({
+            execute: async () => {
+                try {
+                    const servers = await this.mcpFrontendService.getServerNames();
+                    const startedServers = await this.mcpFrontendService.getStartedServers();
+                    const startableServers = servers.filter(server => !startedServers.includes(server));
+                    if (!startableServers || startableServers.length === 0) {
+                        if (startedServers && startedServers.length > 0) {
+                            this.messageService.error('All MCP servers are already running.');
+                        } else {
+                            this.messageService.error('No MCP servers configured.');
+                        }
+                        return;
+                    }
+
+                    const selection = await this.getMCPServerSelection(startableServers);
+                    if (!selection) {
+                        return;
+                    }
+                    await this.mcpFrontendService.startServer(selection);
+                    const { tools } = await this.mcpFrontendService.getTools(selection);
+                    const toolNames = tools.map(tool => tool.name || 'Unnamed Tool').join(', ');
+                    this.messageService.info(
+                        `MCP server "${selection}" successfully started. Registered tools: ${toolNames || 'No tools available.'}`
+                    );
+                } catch (error) {
+                    this.messageService.error('An error occurred while starting the MCP server.');
+                    console.error('Error while starting MCP server:', error);
+                }
+            }
+        }));
+    }
+}

package/src/browser/mcp-frontend-application-contribution.ts

@@ -0,0 +1,158 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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 { FrontendApplicationContribution, PreferenceProvider, PreferenceService } from '@theia/core/lib/browser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { MCPServerDescription, MCPServerManager } from '../common';
+import { MCP_SERVERS_PREF } from './mcp-preferences';
+import { JSONObject } from '@theia/core/shared/@phosphor/coreutils';
+import { MCPFrontendService } from './mcp-frontend-service';
+
+interface MCPServersPreferenceValue {
+    command: string;
+    args?: string[];
+    env?: { [key: string]: string };
+    autostart?: boolean;
+};
+
+interface MCPServersPreference {
+    [name: string]: MCPServersPreferenceValue
+};
+
+namespace MCPServersPreference {
+    export function isValue(obj: unknown): obj is MCPServersPreferenceValue {
+        return !!obj && typeof obj === 'object' &&
+            'command' in obj && typeof obj.command === 'string' &&
+            (!('args' in obj) || Array.isArray(obj.args) && obj.args.every(arg => typeof arg === 'string')) &&
+            (!('env' in obj) || !!obj.env && typeof obj.env === 'object' && Object.values(obj.env).every(value => typeof value === 'string')) &&
+            (!('autostart' in obj) || typeof obj.autostart === 'boolean');
+    }
+}
+
+function filterValidValues(servers: unknown): MCPServersPreference {
+    const result: MCPServersPreference = {};
+    if (!servers || typeof servers !== 'object') {
+        return result;
+    }
+    for (const [name, value] of Object.entries(servers)) {
+        if (typeof name === 'string' && MCPServersPreference.isValue(value)) {
+            result[name] = value;
+        }
+    }
+    return result;
+}
+
+@injectable()
+export class McpFrontendApplicationContribution implements FrontendApplicationContribution {
+
+    @inject(PreferenceService)
+    protected preferenceService: PreferenceService;
+
+    @inject(MCPServerManager)
+    protected manager: MCPServerManager;
+
+    @inject(MCPFrontendService)
+    protected frontendMCPService: MCPFrontendService;
+
+    protected prevServers: Map<string, MCPServerDescription> = new Map();
+
+    onStart(): void {
+        this.preferenceService.ready.then(() => {
+            const servers = filterValidValues(this.preferenceService.get(
+                MCP_SERVERS_PREF,
+                {}
+            ));
+            this.prevServers = this.convertToMap(servers);
+            this.syncServers(this.prevServers);
+            this.autoStartServers(this.prevServers);
+
+            this.preferenceService.onPreferenceChanged(event => {
+                if (event.preferenceName === MCP_SERVERS_PREF) {
+                    this.handleServerChanges(filterValidValues(event.newValue));
+                }
+            });
+        });
+        this.frontendMCPService.registerToolsForAllStartedServers();
+    }
+
+    protected async autoStartServers(servers: Map<string, MCPServerDescription>): Promise<void> {
+        const startedServers = await this.frontendMCPService.getStartedServers();
+        for (const [name, serverDesc] of servers) {
+            if (serverDesc && serverDesc.autostart) {
+                if (!startedServers.includes(name)) {
+                    await this.frontendMCPService.startServer(name);
+                }
+            }
+        }
+    }
+
+    protected handleServerChanges(newServers: MCPServersPreference): void {
+        const oldServers = this.prevServers;
+        const updatedServers = this.convertToMap(newServers);
+
+        for (const [name] of oldServers) {
+            if (!updatedServers.has(name)) {
+                this.manager.removeServer(name);
+            }
+        }
+
+        for (const [name, description] of updatedServers) {
+            const oldDescription = oldServers.get(name);
+            let diff = false;
+            try {
+                // We know that that the descriptions are actual JSONObjects as we construct them ourselves
+                if (!oldDescription || !PreferenceProvider.deepEqual(oldDescription as unknown as JSONObject, description as unknown as JSONObject)) {
+                    diff = true;
+                }
+            } catch (e) {
+                // In some cases the deepEqual function throws an error, so we fall back to assuming that there is a difference
+                // This seems to happen in cases where the objects are structured differently, e.g. whole sub-objects are missing
+                console.debug('Failed to compare MCP server descriptions, assuming a difference', e);
+                diff = true;
+            }
+            if (diff) {
+                this.manager.addOrUpdateServer(description);
+            }
+        }
+
+        this.prevServers = updatedServers;
+    }
+
+    protected syncServers(servers: Map<string, MCPServerDescription>): void {
+
+        for (const [, description] of servers) {
+            this.manager.addOrUpdateServer(description);
+        }
+
+        for (const [name] of this.prevServers) {
+            if (!servers.has(name)) {
+                this.manager.removeServer(name);
+            }
+        }
+    }
+
+    protected convertToMap(servers: MCPServersPreference): Map<string, MCPServerDescription> {
+        const map = new Map<string, MCPServerDescription>();
+        Object.entries(servers).forEach(([name, description]) => {
+            map.set(name, {
+                name,
+                ...description,
+                env: description.env || undefined
+            });
+        });
+        return map;
+    }
+}

package/src/browser/mcp-frontend-module.ts

@@ -0,0 +1,35 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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 { CommandContribution } from '@theia/core';
+import { ContainerModule } from '@theia/core/shared/inversify';
+import { MCPCommandContribution } from './mcp-command-contribution';
+import { FrontendApplicationContribution, PreferenceContribution, RemoteConnectionProvider, ServiceConnectionProvider } from '@theia/core/lib/browser';
+import { MCPServerManager, MCPServerManagerPath } from '../common/mcp-server-manager';
+import { McpServersPreferenceSchema } from './mcp-preferences';
+import { McpFrontendApplicationContribution } from './mcp-frontend-application-contribution';
+import { MCPFrontendService } from './mcp-frontend-service';
+
+export default new ContainerModule(bind => {
+    bind(PreferenceContribution).toConstantValue({ schema: McpServersPreferenceSchema });
+    bind(FrontendApplicationContribution).to(McpFrontendApplicationContribution).inSingletonScope();
+    bind(CommandContribution).to(MCPCommandContribution);
+    bind(MCPServerManager).toDynamicValue(ctx => {
+        const connection = ctx.container.get<ServiceConnectionProvider>(RemoteConnectionProvider);
+        return connection.createProxy<MCPServerManager>(MCPServerManagerPath);
+    }).inSingletonScope();
+    bind(MCPFrontendService).toSelf().inSingletonScope();
+});

package/src/browser/mcp-frontend-service.ts

@@ -0,0 +1,87 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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 { injectable, inject } from '@theia/core/shared/inversify';
+import { MCPServer, MCPServerManager } from '../common/mcp-server-manager';
+import { ToolInvocationRegistry, ToolRequest } from '@theia/ai-core';
+
+@injectable()
+export class MCPFrontendService {
+    @inject(MCPServerManager)
+    protected readonly mcpServerManager: MCPServerManager;
+
+    @inject(ToolInvocationRegistry)
+    protected readonly toolInvocationRegistry: ToolInvocationRegistry;
+
+    async startServer(serverName: string): Promise<void> {
+        await this.mcpServerManager.startServer(serverName);
+        this.registerTools(serverName);
+    }
+
+    async registerToolsForAllStartedServers(): Promise<void> {
+        const startedServers = await this.getStartedServers();
+        for (const serverName of startedServers) {
+            await this.registerTools(serverName);
+        }
+    }
+
+    async registerTools(serverName: string): Promise<void> {
+        const { tools } = await this.getTools(serverName);
+        const toolRequests: ToolRequest[] = tools.map(tool => this.convertToToolRequest(tool, serverName));
+        toolRequests.forEach(toolRequest =>
+            this.toolInvocationRegistry.registerTool(toolRequest)
+        );
+    }
+
+    async stopServer(serverName: string): Promise<void> {
+        this.toolInvocationRegistry.unregisterAllTools(`mcp_${serverName}`);
+        await this.mcpServerManager.stopServer(serverName);
+    }
+
+    getStartedServers(): Promise<string[]> {
+        return this.mcpServerManager.getStartedServers();
+    }
+
+    getServerNames(): Promise<string[]> {
+        return this.mcpServerManager.getServerNames();
+    }
+
+    getTools(serverName: string): ReturnType<MCPServer['getTools']> {
+        return this.mcpServerManager.getTools(serverName);
+    }
+
+    private convertToToolRequest(tool: Awaited<ReturnType<MCPServerManager['getTools']>>['tools'][number], serverName: string): ToolRequest {
+        const id = `mcp_${serverName}_${tool.name}`;
+        return {
+            id: id,
+            name: id,
+            providerName: `mcp_${serverName}`,
+            parameters: ToolRequest.isToolRequestParameters(tool.inputSchema) ? {
+                type: tool.inputSchema.type,
+                properties: tool.inputSchema.properties,
+                required: tool.inputSchema.required
+            } : undefined,
+            description: tool.description,
+            handler: async (arg_string: string) => {
+                try {
+                    return await this.mcpServerManager.callTool(serverName, tool.name, arg_string);
+                } catch (error) {
+                    console.error(`Error in tool handler for ${tool.name} on MCP server ${serverName}:`, error);
+                    throw error;
+                }
+            },
+        };
+    }
+}

package/src/browser/mcp-preferences.ts

@@ -0,0 +1,90 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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 { PreferenceSchema } from '@theia/core/lib/browser/preferences/preference-contribution';
+
+export const MCP_SERVERS_PREF = 'ai-features.mcp.mcpServers';
+
+export const McpServersPreferenceSchema: PreferenceSchema = {
+    type: 'object',
+    properties: {
+        [MCP_SERVERS_PREF]: {
+            type: 'object',
+            title: 'MCP Servers Configuration',
+            markdownDescription: 'Configure MCP servers with command, arguments, optionally environment variables, and autostart.\
+            Each server is identified by a unique key, such as "brave-search" or "filesystem".\
+            To start a server, use the "MCP: Start MCP Server" command, which enables you to select the desired server.\
+            To stop a server, use the "MCP: Stop MCP Server" command.\
+            \n\
+            Example configuration:\n\
+            ```\
+            {\n\
+              "brave-search": {\n\
+                "command": "npx",\n\
+                "args": [\n\
+                  "-y",\n\
+                  "@modelcontextprotocol/server-brave-search"\n\
+                ],\n\
+                "env": {\n\
+                  "BRAVE_API_KEY": "YOUR_API_KEY"\n\
+                },\n\
+                "autostart": true\n\
+              },\n\
+              "filesystem": {\n\
+                "command": "npx",\n\
+                "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/YOUR_USERNAME/Desktop"],\n\
+                "env": {\n\
+                  "CUSTOM_ENV_VAR": "custom-value"\n\
+                },\n\
+                "autostart": false\n\
+              }\n\
+            }\n            ```',
+            additionalProperties: {
+                type: 'object',
+                properties: {
+                    command: {
+                        type: 'string',
+                        title: 'Command to execute the MCP server',
+                        markdownDescription: 'The command used to start the MCP server, e.g., "uvx" or "npx".'
+                    },
+                    args: {
+                        type: 'array',
+                        title: 'Arguments for the command',
+                        markdownDescription: 'An array of arguments to pass to the command.',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    env: {
+                        type: 'object',
+                        title: 'Environment variables',
+                        markdownDescription: 'Optional environment variables to set for the server, such as an API key.',
+                        additionalProperties: {
+                            type: 'string'
+                        }
+                    },
+                    autostart: {
+                        type: 'boolean',
+                        title: 'Autostart',
+                        markdownDescription: 'Automatically start this server when the frontend starts. Newly added servers are not immediatly auto stated.',
+                        default: false
+                    }
+                },
+                required: ['command', 'args']
+            }
+        }
+    }
+};

package/src/common/index.ts

@@ -0,0 +1,16 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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
+// *****************************************************************************
+export * from './mcp-server-manager';

package/src/common/mcp-server-manager.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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 { Client } from '@modelcontextprotocol/sdk/client/index';
+
+export interface MCPServer {
+    callTool(toolName: string, arg_string: string): ReturnType<Client['callTool']>;
+    getTools(): ReturnType<Client['listTools']>;
+}
+
+export interface MCPServerManager {
+    callTool(serverName: string, toolName: string, arg_string: string): ReturnType<MCPServer['callTool']>;
+    removeServer(name: string): void;
+    addOrUpdateServer(description: MCPServerDescription): void;
+    getTools(serverName: string): ReturnType<MCPServer['getTools']>
+    getServerNames(): Promise<string[]>;
+    startServer(serverName: string): Promise<void>;
+    stopServer(serverName: string): Promise<void>;
+    getStartedServers(): Promise<string[]>;
+}
+
+export interface MCPServerDescription {
+    /**
+     * The unique name of the MCP server.
+     */
+    name: string;
+
+    /**
+     * The command to execute the MCP server.
+     */
+    command: string;
+
+    /**
+     * An array of arguments to pass to the command.
+     */
+    args?: string[];
+
+    /**
+     * Optional environment variables to set when starting the server.
+     */
+    env?: { [key: string]: string };
+
+    /**
+     * Flag indicating whether the server should automatically start when the application starts.
+     */
+    autostart?: boolean;
+}
+
+export const MCPServerManager = Symbol('MCPServerManager');
+export const MCPServerManagerPath = '/services/mcpservermanager';

package/src/node/mcp-backend-module.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource GmbH.
+//
+// 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 { ContainerModule } from '@theia/core/shared/inversify';
+import { ConnectionHandler, RpcConnectionHandler } from '@theia/core';
+import { MCPServerManagerImpl } from './mcp-server-manager-impl';
+import { MCPServerManager, MCPServerManagerPath } from '../common/mcp-server-manager';
+import { ConnectionContainerModule } from '@theia/core/lib/node/messaging/connection-container-module';
+
+// We use a connection module to handle AI services separately for each frontend.
+const mcpConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService, bindFrontendService }) => {
+    bind(MCPServerManager).to(MCPServerManagerImpl).inSingletonScope();
+    bind(ConnectionHandler).toDynamicValue(ctx => new RpcConnectionHandler(
+        MCPServerManagerPath,
+        () => {
+            const service = ctx.container.get<MCPServerManager>(MCPServerManager);
+            return service;
+        }
+    )).inSingletonScope();
+});
+
+export default new ContainerModule(bind => {
+    bind(ConnectionContainerModule).toConstantValue(mcpConnectionModule);
+});