@theia/ai-mcp-server 1.65.0

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

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// 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 { ContainerModule } from '@theia/core/shared/inversify';
+import { bindContributionProvider } from '@theia/core';
+import { FrontendApplicationContribution } from '@theia/core/lib/browser';
+import {
+    RemoteConnectionProvider,
+    ServiceConnectionProvider,
+} from '@theia/core/lib/browser/messaging/service-connection-provider';
+import { MCPToolFrontendDelegate, MCPToolDelegateClient, mcpToolDelegatePath } from '../common/mcp-tool-delegate';
+import { MCPFrontendBootstrap } from './mcp-frontend-bootstrap';
+import { MCPFrontendContribution } from './mcp-frontend-contribution';
+import { MCPToolDelegateClientImpl } from './mcp-tool-delegate-client';
+
+export default new ContainerModule(bind => {
+    bind(MCPFrontendBootstrap).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(MCPFrontendBootstrap);
+
+    bind(MCPToolDelegateClient).to(MCPToolDelegateClientImpl).inSingletonScope();
+
+    bind(MCPToolFrontendDelegate).toDynamicValue(ctx => {
+        const connection = ctx.container.get<ServiceConnectionProvider>(RemoteConnectionProvider);
+        const client = ctx.container.get<MCPToolDelegateClient>(MCPToolDelegateClient);
+        return connection.createProxy<MCPToolFrontendDelegate>(mcpToolDelegatePath, client);
+    }).inSingletonScope();
+
+    bindContributionProvider(bind, MCPFrontendContribution);
+});

package/src/browser/mcp-tool-delegate-client.ts

@@ -0,0 +1,133 @@
+// *****************************************************************************
+// 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 { inject, injectable, named } from '@theia/core/shared/inversify';
+import { ContributionProvider } from '@theia/core';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { Tool, Resource, ResourceContents, Prompt, PromptMessage } from '@modelcontextprotocol/sdk/types';
+import { MCPToolDelegateClient } from '../common/mcp-tool-delegate';
+import { MCPFrontendContribution } from './mcp-frontend-contribution';
+
+/**
+ * Frontend client implementation that handles MCP tool delegation requests from the backend.
+ *
+ * This class acts as a bridge between the backend MCP server and frontend contributions,
+ * forwarding backend requests (tool calls, resource access, prompts) to registered
+ * MCPFrontendContribution instances and aggregating their responses.
+ *
+ * Called by the backend via the MCPToolDelegateClient interface to access frontend-provided
+ * MCP tools, resources, and prompts.
+ */
+@injectable()
+export class MCPToolDelegateClientImpl implements MCPToolDelegateClient {
+
+    @inject(ContributionProvider)
+    @named(MCPFrontendContribution)
+    protected readonly contributions: ContributionProvider<MCPFrontendContribution>;
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    private getFrontendContributions(): MCPFrontendContribution[] {
+        return this.contributions.getContributions();
+    }
+
+    async callTool(serverId: string, toolName: string, args: unknown): Promise<unknown> {
+        const contributions = this.getFrontendContributions();
+
+        for (const contribution of contributions) {
+            if (contribution.getTool) {
+                const tool = await contribution.getTool(toolName);
+                if (tool) {
+                    return await tool.handler(JSON.stringify(args));
+                }
+            }
+        }
+        throw new Error(`Tool ${toolName} not found in server ${serverId}`);
+    }
+
+    async listTools(serverId: string): Promise<Tool[]> {
+        const contributions = this.getFrontendContributions();
+        const allTools: Tool[] = [];
+
+        for (const contribution of contributions) {
+            if (contribution.getTools) {
+                const tools = await contribution.getTools();
+                allTools.push(...tools);
+            }
+        }
+        return allTools;
+    }
+
+    async listResources(serverId: string): Promise<Resource[]> {
+        const contributions = this.getFrontendContributions();
+        const allResources: Resource[] = [];
+
+        for (const contribution of contributions) {
+            if (contribution.getResources) {
+                const resources = await contribution.getResources();
+                allResources.push(...resources);
+            }
+        }
+        return allResources;
+    }
+
+    async readResource(serverId: string, uri: string): Promise<ResourceContents> {
+        const contributions = this.getFrontendContributions();
+
+        for (const contribution of contributions) {
+            if (contribution.readResource) {
+                try {
+                    const result = await contribution.readResource(uri);
+                    return result as ResourceContents;
+                } catch (error) {
+                    // Continue to next contribution
+                    this.logger.debug(`Error getting resource ${uri}:`, error);
+                }
+            }
+        }
+        throw new Error(`Resource ${uri} not found in server ${serverId}`);
+    }
+
+    async listPrompts(serverId: string): Promise<Prompt[]> {
+        const contributions = this.getFrontendContributions();
+        const allPrompts: Prompt[] = [];
+
+        for (const contribution of contributions) {
+            if (contribution.getPrompts) {
+                const prompts = await contribution.getPrompts();
+                allPrompts.push(...prompts);
+            }
+        }
+        return allPrompts;
+    }
+
+    async getPrompt(serverId: string, name: string, args: unknown): Promise<PromptMessage[]> {
+        const contributions = this.getFrontendContributions();
+
+        for (const contribution of contributions) {
+            if (contribution.getPrompt) {
+                try {
+                    return await contribution.getPrompt(name, args);
+                } catch (error) {
+                    // Continue to next contribution
+                    this.logger.debug(`Error getting prompt ${name}:`, error);
+                }
+            }
+        }
+        throw new Error(`Prompt ${name} not found in server ${serverId}`);
+    }
+}

package/src/common/index.ts

@@ -0,0 +1,17 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+export * from './mcp-tool-delegate';

package/src/common/mcp-tool-delegate.ts

@@ -0,0 +1,43 @@
+// *****************************************************************************
+// 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 { Tool, Resource, ResourceContents, Prompt, PromptMessage } from '@modelcontextprotocol/sdk/types';
+
+export const MCPToolDelegateClient = Symbol('MCPToolDelegateClient');
+/**
+ * Client interface for MCP tool operations.
+ * This interface is implemented by the frontend and called by the backend.
+ */
+export interface MCPToolDelegateClient {
+    callTool(serverId: string, toolName: string, args: unknown): Promise<unknown>;
+    listTools(serverId: string): Promise<Tool[]>;
+    listResources(serverId: string): Promise<Resource[]>;
+    readResource(serverId: string, uri: string): Promise<ResourceContents>;
+    listPrompts(serverId: string): Promise<Prompt[]>;
+    getPrompt(serverId: string, name: string, args: unknown): Promise<PromptMessage[]>;
+}
+
+export const MCPToolFrontendDelegate = Symbol('MCPToolFrontendDelegate');
+/**
+ * Backend delegate interface for MCP tool operations.
+ * This interface extends MCPToolDelegateClient with RPC client setup capability.
+ * It is implemented by the backend and acts as a proxy to forward calls to the frontend.
+ */
+export interface MCPToolFrontendDelegate extends MCPToolDelegateClient {
+    setClient(client: MCPToolDelegateClient): void;
+}
+
+export const mcpToolDelegatePath = '/services/mcpToolDelegate';

package/src/node/index.ts

@@ -0,0 +1,20 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+export * from './mcp-theia-server';
+export * from './mcp-theia-server-impl';
+export * from './mcp-backend-contribution-manager';
+export * from './mcp-frontend-contribution-manager';

package/src/node/mcp-backend-contribution-manager.ts

@@ -0,0 +1,56 @@
+// *****************************************************************************
+// 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 { inject, injectable, named } from '@theia/core/shared/inversify';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { ContributionProvider } from '@theia/core/lib/common/contribution-provider';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { MCPBackendContribution } from './mcp-theia-server';
+
+/**
+ * Manages the registration of backend MCP contributions
+ */
+@injectable()
+export class MCPBackendContributionManager {
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    @inject(ContributionProvider)
+    @named(MCPBackendContribution)
+    protected readonly contributions: ContributionProvider<MCPBackendContribution>;
+
+    /**
+     * Register all backend contributions with the MCP server
+     */
+    async registerBackendContributions(server: McpServer): Promise<void> {
+        const contributions = this.contributions.getContributions();
+        this.logger.debug(`Found ${contributions.length} backend MCP contributions to register`);
+
+        for (const contribution of contributions) {
+            try {
+                this.logger.debug(`Configuring backend MCP contribution: ${contribution.constructor.name}`);
+                await contribution.configure(server);
+                this.logger.debug(`Successfully registered backend MCP contribution: ${contribution.constructor.name}`);
+            } catch (error) {
+                this.logger.error(`Failed to register backend MCP contribution ${contribution.constructor.name}:`, error);
+                throw error;
+            }
+        }
+
+        this.logger.debug(`Finished registering all ${contributions.length} backend MCP contributions`);
+    }
+}

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

@@ -0,0 +1,75 @@
+// *****************************************************************************
+// 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 { ContainerModule } from '@theia/core/shared/inversify';
+import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
+import { ConnectionContainerModule } from '@theia/core/lib/node/messaging/connection-container-module';
+import { ConnectionHandler, RpcConnectionHandler, bindContributionProvider, generateUuid } from '@theia/core';
+import {
+    MCPTheiaServer,
+    MCPBackendContribution
+} from './mcp-theia-server';
+import { MCPToolFrontendDelegate, MCPToolDelegateClient, mcpToolDelegatePath } from '../common/mcp-tool-delegate';
+import { MCPTheiaServerImpl } from './mcp-theia-server-impl';
+import { MCPBackendContributionManager } from './mcp-backend-contribution-manager';
+import { MCPFrontendContributionManager } from './mcp-frontend-contribution-manager';
+import { MCPToolFrontendDelegateImpl } from './mcp-tool-frontend-delegate';
+
+const mcpConnectionModule = ConnectionContainerModule.create(({ bind }) => {
+    bind(MCPToolFrontendDelegateImpl).toSelf().inSingletonScope();
+    bind(MCPToolFrontendDelegate).toService(MCPToolFrontendDelegateImpl);
+
+    bind(ConnectionHandler)
+        .toDynamicValue(
+            ({ container }) =>
+                new RpcConnectionHandler<MCPToolDelegateClient>(
+                    mcpToolDelegatePath,
+                    client => {
+                        const service = container.get<MCPToolFrontendDelegateImpl>(MCPToolFrontendDelegateImpl);
+                        const contributionManager = container.get<MCPFrontendContributionManager>(MCPFrontendContributionManager);
+
+                        service.setClient(client);
+
+                        // Generate unique delegate ID and register with contribution manager
+                        const delegateId = generateUuid();
+                        contributionManager.addFrontendDelegate(delegateId, service);
+
+                        // Setup cleanup when connection closes
+                        client.onDidCloseConnection(() => {
+                            contributionManager.removeFrontendDelegate(delegateId);
+                        });
+
+                        return service;
+                    }
+                )
+        )
+        .inSingletonScope();
+});
+
+export default new ContainerModule(bind => {
+
+    bind(MCPTheiaServerImpl).toSelf().inSingletonScope();
+    bind(MCPTheiaServer).toService(MCPTheiaServerImpl);
+    bind(BackendApplicationContribution).toService(MCPTheiaServerImpl);
+
+    bind(MCPBackendContributionManager).toSelf().inSingletonScope();
+
+    bind(MCPFrontendContributionManager).toSelf().inSingletonScope();
+
+    bindContributionProvider(bind, MCPBackendContribution);
+
+    bind(ConnectionContainerModule).toConstantValue(mcpConnectionModule);
+});

package/src/node/mcp-frontend-contribution-manager.ts

@@ -0,0 +1,268 @@
+// *****************************************************************************
+// 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 { inject, injectable } from '@theia/core/shared/inversify';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { McpServer, RegisteredTool, RegisteredPrompt, RegisteredResource } from '@modelcontextprotocol/sdk/server/mcp';
+import { ReadResourceResult } from '@modelcontextprotocol/sdk/types';
+import { MCPToolFrontendDelegate } from '../common/mcp-tool-delegate';
+
+/**
+ * Manages the registration and delegation of frontend MCP contributions
+ */
+@injectable()
+export class MCPFrontendContributionManager {
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    // Frontend delegates are set dynamically when connections are established
+    private frontendDelegates = new Map<string, MCPToolFrontendDelegate>();
+    private mcpServer?: McpServer;
+    private serverId?: string;
+
+    private registeredElements: Map<string, (RegisteredTool | RegisteredPrompt | RegisteredResource)[]> = new Map();
+
+    /**
+     * Set the MCP server instance and setup frontend delegate notifications
+     */
+    async setMCPServer(server: McpServer, serverId: string): Promise<void> {
+        this.mcpServer = server;
+        this.serverId = serverId;
+        this.registerExistingFrontendContributions();
+    }
+
+    /**
+     * Add a frontend delegate (called when a frontend connection is established)
+     */
+    addFrontendDelegate(delegateId: string, delegate: MCPToolFrontendDelegate): void {
+        this.frontendDelegates.set(delegateId, delegate);
+
+        if (this.mcpServer && this.serverId) {
+            this.registerFrontendContributionsFromDelegate(delegateId, delegate).catch(error => {
+                this.logger.warn(`Failed to register frontend contributions from delegate ${delegateId}:`, error);
+            });
+        }
+    }
+
+    /**
+     * Remove a frontend delegate (called when a frontend connection is closed)
+     */
+    removeFrontendDelegate(delegateId: string): void {
+        this.frontendDelegates.delete(delegateId);
+        this.unregisterFrontendContributionsFromDelegate(delegateId);
+    }
+
+    /**
+     * Unregister frontend contributions from a specific delegate
+     */
+    private unregisterFrontendContributionsFromDelegate(delegateId: string): void {
+        if (!this.mcpServer) {
+            this.logger.warn('MCP server not set, cannot unregister frontend contributions');
+            return;
+        }
+
+        const elements = this.registeredElements.get(delegateId);
+        if (elements) {
+            for (const element of elements) {
+                try {
+                    element.remove();
+                } catch (error) {
+                    this.logger.warn(`Failed to unregister element from delegate ${delegateId}: ${error}`);
+                }
+            }
+            this.registeredElements.delete(delegateId);
+
+            // Notify that lists have changed
+            this.mcpServer.sendToolListChanged();
+            this.mcpServer.sendResourceListChanged();
+            this.mcpServer.sendPromptListChanged();
+        }
+    }
+
+    /**
+     * Register frontend contributions from existing delegates
+     */
+    private async registerExistingFrontendContributions(): Promise<void> {
+        for (const [delegateId, delegate] of this.frontendDelegates) {
+            try {
+                await this.registerFrontendContributionsFromDelegate(delegateId, delegate);
+            } catch (error) {
+                this.logger.warn(`Failed to register frontend contributions from delegate ${delegateId}:`, error);
+            }
+        }
+    }
+
+    /**
+     * Register frontend contributions from a specific delegate
+     */
+    private async registerFrontendContributionsFromDelegate(delegateId: string, delegate: MCPToolFrontendDelegate): Promise<void> {
+        if (!this.mcpServer || !this.serverId) {
+            this.logger.warn('MCP server not set, cannot register frontend contributions');
+            return;
+        }
+
+        try {
+            await this.registerFrontendToolsFromDelegate(delegate, delegateId);
+            this.mcpServer.sendToolListChanged();
+            // Register resources from frontend
+            await this.registerFrontendResourcesFromDelegate(delegate, delegateId);
+            this.mcpServer.sendResourceListChanged();
+
+            // Register prompts from frontend
+            await this.registerFrontendPromptsFromDelegate(delegate, delegateId);
+            this.mcpServer.sendPromptListChanged();
+
+        } catch (error) {
+            this.logger.warn(`Failed to register frontend MCP contributions from delegate ${delegateId}: ${error}`);
+            // Don't re-throw to prevent server startup failure
+        }
+    }
+
+    /**
+     * Unregister frontend contributions for a server
+     * @param serverId Unique identifier for the server instance
+     */
+    async unregisterFrontendContributions(serverId: string): Promise<void> {
+        for (const [delegateId] of this.frontendDelegates) {
+            try {
+                this.unregisterFrontendContributionsFromDelegate(delegateId);
+                // Backend delegates don't need lifecycle notifications
+            } catch (error) {
+                this.logger.warn(`Error unregistering server from frontend delegate ${delegateId}:`, error);
+            }
+        }
+    }
+
+    /**
+     * Register tools from frontend contributions
+     */
+    protected async registerFrontendToolsFromDelegate(delegate: MCPToolFrontendDelegate, delegateId: string): Promise<void> {
+        if (!this.mcpServer || !this.serverId) {
+            throw new Error('MCP server not set');
+        }
+
+        try {
+            const tools = await delegate.listTools(this.serverId);
+            for (const tool of tools) {
+                const registeredTool = this.mcpServer.tool(
+                    `${tool.name}_${delegateId}`,
+                    tool.description ?? '',
+                    tool.inputSchema,
+                    async args => {
+                        try {
+                            const result = await delegate.callTool(
+                                this.serverId!,
+                                tool.name,
+                                args
+                            );
+                            return {
+                                content: [{
+                                    type: 'text',
+                                    text: typeof result === 'string' ? result : JSON.stringify(result)
+                                }]
+                            };
+                        } catch (error) {
+                            this.logger.error(`Error calling frontend tool ${tool.name}:`, error);
+                            throw error;
+                        }
+                    }
+                );
+                const registeredElements = this.registeredElements.get(delegateId) ?? [];
+                registeredElements.push(registeredTool);
+                this.registeredElements.set(delegateId, registeredElements);
+            }
+
+        } catch (error) {
+            this.logger.warn(`Failed to register frontend tools from delegate ${delegateId}: ${error}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Register resources from frontend contributions
+     */
+    protected async registerFrontendResourcesFromDelegate(delegate: MCPToolFrontendDelegate, delegateId: string): Promise<void> {
+        if (!this.mcpServer || !this.serverId) {
+            throw new Error('MCP server not set');
+        }
+
+        try {
+            const resources = await delegate.listResources(this.serverId);
+
+            for (const resource of resources) {
+                const registeredResource = this.mcpServer.resource(
+                    `${resource.name}_${delegateId}`,
+                    resource.uri,
+                    async uri => {
+                        try {
+                            const result = await delegate.readResource(this.serverId!, uri.href);
+                            return result as unknown as ReadResourceResult;
+                        } catch (error) {
+                            this.logger.error(`Error reading frontend resource ${resource.name}:`, error);
+                            throw error;
+                        }
+                    }
+                );
+                const registeredElements = this.registeredElements.get(delegateId) ?? [];
+                registeredElements.push(registeredResource);
+                this.registeredElements.set(delegateId, registeredElements);
+            }
+
+        } catch (error) {
+            this.logger.warn(`Failed to register frontend resources from delegate ${delegateId}: ${error}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Register prompts from frontend contributions
+     */
+    protected async registerFrontendPromptsFromDelegate(delegate: MCPToolFrontendDelegate, delegateId: string): Promise<void> {
+        if (!this.mcpServer || !this.serverId) {
+            throw new Error('MCP server not set');
+        }
+
+        try {
+            const prompts = await delegate.listPrompts(this.serverId);
+
+            for (const prompt of prompts) {
+                const registeredPrompt = this.mcpServer.prompt(
+                    `${prompt.name}_${delegateId}`,
+                    prompt.description ?? '',
+                    prompt.arguments ?? {},
+                    async args => {
+                        try {
+                            const messages = await delegate.getPrompt(this.serverId!, prompt.name, args);
+                            return {
+                                messages
+                            };
+                        } catch (error) {
+                            this.logger.error(`Error getting frontend prompt ${prompt.name}:`, error);
+                            throw error;
+                        }
+                    }
+                );
+                const registeredElements = this.registeredElements.get(delegateId) ?? [];
+                registeredElements.push(registeredPrompt);
+                this.registeredElements.set(delegateId, registeredElements);
+            }
+        } catch (error) {
+            this.logger.warn(`Failed to register frontend prompts from delegate ${delegateId}: ${error}`);
+            throw error;
+        }
+    }
+}