@eclipse-glsp/server-mcp 2.7.0-next.9

package/src/server/glsp-mcp-server.ts

@@ -0,0 +1,196 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Disposable, Logger, McpServerOptions } from '@eclipse-glsp/server';
+import {
+    McpServer,
+    RegisteredPrompt,
+    RegisteredResource,
+    RegisteredResourceTemplate,
+    RegisteredTool
+} from '@modelcontextprotocol/sdk/server/mcp.js';
+import { EmptyResultSchema, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { injectable, unmanaged } from 'inversify';
+
+export const GLSPMcpServer = Symbol('GLSPMcpServer');
+
+/** Either a static resource or a templated resource registration. */
+export type GLSPMcpResource = RegisteredResource | RegisteredResourceTemplate;
+
+/**
+ * Cadence for server-initiated `ping` requests on the standalone SSE GET stream. Shorter than
+ * typical client-side SSE read timeouts (e.g. undici's 5-min `bodyTimeout`) so the stream stays
+ * alive across chat-idle periods.
+ */
+const KEEP_ALIVE_INTERVAL_MS = 30_000;
+
+/** Per-ping timeout — short, since a ping with no SSE GET stream open will never resolve. */
+const KEEP_ALIVE_PING_TIMEOUT_MS = 5_000;
+
+/**
+ * Curated, per-session view onto the underlying MCP server. Handlers see this during
+ * registration; the launcher disposes it on session-close and on server shutdown.
+ */
+export interface GLSPMcpServer
+    extends Pick<McpServer, 'registerPrompt' | 'registerResource' | 'registerTool' | 'sendLoggingMessage' | 'isConnected' | 'connect'>,
+        Disposable {
+    readonly options: McpServerOptions;
+
+    /** Register a tool. Wraps the SDK's {@link McpServer.registerTool} and updates the local log. */
+    readonly registerTool: McpServer['registerTool'];
+    /** Register a resource. Wraps the SDK's {@link McpServer.registerResource} and updates the local log. */
+    readonly registerResource: McpServer['registerResource'];
+    /** Register a prompt. Wraps the SDK's {@link McpServer.registerPrompt} and updates the local log. */
+    readonly registerPrompt: McpServer['registerPrompt'];
+    /** Send an LLM-facing log message via the MCP `logging/message` notification. */
+    sendLoggingMessage: McpServer['sendLoggingMessage'];
+    /** True iff a transport is currently connected. */
+    isConnected: McpServer['isConnected'];
+    /** Attach the supplied transport. */
+    connect: McpServer['connect'];
+
+    listTools(): RegisteredTool[];
+    /** True iff a tool with this exact `name` has been registered on this server instance. */
+    hasTool(name: string): boolean;
+    listResources(): GLSPMcpResource[];
+    listPrompts(): RegisteredPrompt[];
+    /** Sends an MCP `ping` and resolves on empty result, rejects on transport timeout. */
+    ping(): Promise<void>;
+    /**
+     * Escape hatch to the underlying SDK `McpServer` for advanced APIs not covered by the
+     * stable surface. The returned value is the SDK type, not a stable GLSP surface.
+     */
+    getRawServer(): McpServer;
+}
+
+export const GLSPMcpServerFactory = Symbol('GLSPMcpServerFactory');
+
+/**
+ * Factory that produces a {@link GLSPMcpServer} per MCP client session.
+ * Bound to {@link DefaultGLSPMcpServer} by default; rebind to swap the
+ * implementation across all sessions.
+ */
+export type GLSPMcpServerFactory = (mcpServer: McpServer, options: McpServerOptions) => GLSPMcpServer;
+
+@injectable()
+export class DefaultGLSPMcpServer implements GLSPMcpServer {
+    protected readonly tools = new Map<string, RegisteredTool>();
+    protected readonly resources = new Map<string, GLSPMcpResource>();
+    protected readonly prompts = new Map<string, RegisteredPrompt>();
+    protected keepAliveTimer?: NodeJS.Timeout;
+
+    readonly registerTool: McpServer['registerTool'];
+    readonly registerResource: McpServer['registerResource'];
+    readonly registerPrompt: McpServer['registerPrompt'];
+
+    constructor(
+        @unmanaged() protected readonly mcpServer: McpServer,
+        @unmanaged() readonly options: McpServerOptions,
+        @unmanaged() protected readonly logger: Logger
+    ) {
+        // `register*` need an interception layer so the local registration log stays in
+        // sync; the Proxy preserves the SDK's generic signatures (which a wrapped method
+        // using `Parameters<>` would collapse, breaking adopter autocomplete on
+        // `inputSchema → handler arg shape`).
+        const { tools, resources, prompts } = this;
+        this.registerTool = new Proxy(mcpServer.registerTool.bind(mcpServer), {
+            apply(target, thisArg, args) {
+                const registered = Reflect.apply(target, thisArg, args);
+                if (typeof args[0] === 'string') {
+                    tools.set(args[0], registered);
+                }
+                return registered;
+            }
+        });
+        this.registerResource = new Proxy(mcpServer.registerResource.bind(mcpServer), {
+            apply(target, thisArg, args) {
+                const registered = Reflect.apply(target, thisArg, args);
+                if (typeof args[0] === 'string') {
+                    resources.set(args[0], registered);
+                }
+                return registered;
+            }
+        });
+        this.registerPrompt = new Proxy(mcpServer.registerPrompt.bind(mcpServer), {
+            apply(target, thisArg, args) {
+                const registered = Reflect.apply(target, thisArg, args);
+                if (typeof args[0] === 'string') {
+                    prompts.set(args[0], registered);
+                }
+                return registered;
+            }
+        });
+    }
+
+    sendLoggingMessage(...args: Parameters<McpServer['sendLoggingMessage']>): ReturnType<McpServer['sendLoggingMessage']> {
+        return this.mcpServer.sendLoggingMessage(...args);
+    }
+
+    async connect(...args: Parameters<McpServer['connect']>): ReturnType<McpServer['connect']> {
+        await this.mcpServer.connect(...args);
+        // Suppress the expected `RequestTimeout` when no SSE GET stream is open; surface other
+        // failures via debug. `unref` so a forgotten timer can't pin the process.
+        this.keepAliveTimer = setInterval(
+            () =>
+                this.ping().catch(err => {
+                    if (!(err instanceof McpError) || err.code !== ErrorCode.RequestTimeout) {
+                        this.logger.debug('MCP keep-alive ping failed:', err);
+                    }
+                }),
+            KEEP_ALIVE_INTERVAL_MS
+        );
+        this.keepAliveTimer.unref();
+    }
+
+    isConnected(): boolean {
+        return this.mcpServer.isConnected();
+    }
+
+    async ping(): Promise<void> {
+        // Bypass `Server.ping()` to pass a per-request timeout; SDK's no-arg wrapper uses the
+        // 60s default, which leaves keep-alive pings dangling for a full minute when no SSE GET
+        // stream is open.
+        await this.mcpServer.server.request({ method: 'ping' }, EmptyResultSchema, { timeout: KEEP_ALIVE_PING_TIMEOUT_MS });
+    }
+
+    listTools(): RegisteredTool[] {
+        return [...this.tools.values()];
+    }
+
+    hasTool(name: string): boolean {
+        return this.tools.has(name);
+    }
+
+    listResources(): GLSPMcpResource[] {
+        return [...this.resources.values()];
+    }
+
+    listPrompts(): RegisteredPrompt[] {
+        return [...this.prompts.values()];
+    }
+
+    getRawServer(): McpServer {
+        return this.mcpServer;
+    }
+
+    dispose(): void {
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = undefined;
+        }
+        this.mcpServer.close();
+    }
+}

package/src/server/index.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+export * from './glsp-mcp-server';
+export * from './mcp-diagram-handler-dispatcher';
+export * from './mcp-diagram-prompt-handler-registry';
+export * from './mcp-diagram-resource-handler-registry';
+export * from './mcp-diagram-tool-handler-registry';
+export * from './mcp-handler-shared';
+export * from './mcp-http-transport';
+export * from './mcp-id-alias-service';
+export * from './mcp-input-schemas';
+export * from './mcp-label-provider';
+export * from './mcp-log-level-registry';
+export * from './mcp-logger';
+export * from './mcp-mime-types';
+export * from './mcp-options';
+export * from './mcp-progress-reporter';
+export * from './mcp-prompt-handler';
+export * from './mcp-request-context';
+export * from './mcp-resource-handler';
+export * from './mcp-server-launcher';
+export * from './mcp-session';
+export * from './mcp-tool-handler';
+
+// `mcp-diagram-module` and `mcp-server-module` are intentionally not re-exported here —
+// they import handler classes from `../resources` / `../tools`, which would create a circular
+// import chain through this barrel. They are re-exported from the package root (`src/index.ts`)
+// after the handler barrels finish initializing.

package/src/server/lru-event-store.spec.ts

@@ -0,0 +1,121 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Logger } from '@eclipse-glsp/server';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { expect } from 'chai';
+import { LruEventStore } from './lru-event-store';
+
+function jsonRpc(id: number): JSONRPCMessage {
+    return { jsonrpc: '2.0', id, result: { value: id } };
+}
+
+describe('LruEventStore', () => {
+    it('rejects an invalid limit (< 1)', () => {
+        expect(() => new LruEventStore(0)).to.throw(/limit must be >= 1/);
+        expect(() => new LruEventStore(-5)).to.throw(/limit must be >= 1/);
+    });
+
+    it('storeEvent returns a streamId-prefixed event id', async () => {
+        const store = new LruEventStore();
+        const id = await store.storeEvent('stream-A', jsonRpc(1));
+        expect(id.split('_')[0]).to.equal('stream-A');
+    });
+
+    it('evicts the oldest event once the cap is exceeded', async () => {
+        const store = new LruEventStore(3);
+        const id1 = await store.storeEvent('s', jsonRpc(1));
+        const id2 = await store.storeEvent('s', jsonRpc(2));
+        await store.storeEvent('s', jsonRpc(3));
+
+        expect(store.size).to.equal(3);
+
+        // Adding a 4th event evicts the oldest (id1).
+        const id4 = await store.storeEvent('s', jsonRpc(4));
+        expect(store.size).to.equal(3);
+
+        // Replay since id1 → can't find it (evicted) → returns ''.
+        const replayed: string[] = [];
+        const streamId = await store.replayEventsAfter(id1, {
+            send: async eventId => {
+                replayed.push(eventId);
+            }
+        });
+        expect(streamId).to.equal(''); // id1 has been evicted
+        expect(replayed).to.have.lengthOf(0);
+
+        // Replay since id2 still works — id3 (still in store) and id4 are sent in order.
+        const replayedFromId2: string[] = [];
+        await store.replayEventsAfter(id2, {
+            send: async eventId => {
+                replayedFromId2.push(eventId);
+            }
+        });
+        expect(replayedFromId2).to.have.lengthOf(2);
+        expect(replayedFromId2[1]).to.equal(id4);
+    });
+
+    it('replays only events from the same stream after the lastEventId', async () => {
+        const store = new LruEventStore();
+        const a1 = await store.storeEvent('A', jsonRpc(1));
+        await store.storeEvent('B', jsonRpc(2)); // different stream — must be skipped
+        const a3 = await store.storeEvent('A', jsonRpc(3));
+        const a4 = await store.storeEvent('A', jsonRpc(4));
+
+        const replayed: Array<{ id: string; msg: JSONRPCMessage }> = [];
+        const streamId = await store.replayEventsAfter(a1, {
+            send: async (id, msg) => {
+                replayed.push({ id, msg });
+            }
+        });
+
+        expect(streamId).to.equal('A');
+        expect(replayed.map(e => e.id)).to.deep.equal([a3, a4]);
+    });
+
+    it('returns "" when lastEventId is unknown', async () => {
+        const store = new LruEventStore();
+        await store.storeEvent('A', jsonRpc(1));
+
+        const streamId = await store.replayEventsAfter('A_999_xxx', {
+            send: async () => {
+                throw new Error('should not be called');
+            }
+        });
+
+        expect(streamId).to.equal('');
+    });
+
+    it('logs a cap-eviction warn when replaying an evicted last-event-id', async () => {
+        const warns: string[] = [];
+        const logger = { warn: (message: string) => warns.push(message) } as unknown as Logger;
+        const store = new LruEventStore(2, logger);
+        const evictedId = await store.storeEvent('s', jsonRpc(1));
+        await store.storeEvent('s', jsonRpc(2));
+        await store.storeEvent('s', jsonRpc(3));
+
+        const streamId = await store.replayEventsAfter(evictedId, {
+            send: async () => {
+                throw new Error('should not be called');
+            }
+        });
+
+        expect(streamId).to.equal('');
+        expect(warns).to.have.lengthOf(1);
+        expect(warns[0]).to.match(/Replay miss/);
+        expect(warns[0]).to.include('Cap is 2');
+    });
+});

package/src/server/lru-event-store.ts

@@ -0,0 +1,112 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Logger } from '@eclipse-glsp/server';
+import { EventId, EventStore, StreamId } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * In-memory `EventStore` with a bounded LRU cap, replacing the SDK's `InMemoryEventStore`
+ * (which is unbounded and explicitly intended only for examples).
+ *
+ * Resumability via `Last-Event-ID` requires that historical events stay reachable. Without a
+ * cap, the underlying `Map` grows linearly with `MCP message volume × server uptime` — fine
+ * for local-dev, a slow leak for daemonised / multi-user / CI deployments.
+ *
+ * Eviction shape: insert-order LRU. JS `Map` already preserves insertion order, so newer
+ * events sit at the tail and `keys().next()` returns the oldest. On overflow we delete the
+ * oldest — no timer, no periodic sweep, no `dispose()` plumbing required. The cap must be
+ * comfortably larger than the worst-case in-flight event count (per-client × concurrent-clients
+ * × disconnect-window), or a client reconnecting with a stale `Last-Event-ID` will find its
+ * resume point already evicted.
+ *
+ * The event-id format mirrors the SDK's example impl (`<streamId>_<timestamp>_<random>`) so
+ * `replayEventsAfter` can extract the stream id with the same `split('_')[0]` trick.
+ */
+export class LruEventStore implements EventStore {
+    static readonly DEFAULT_LIMIT = 10_000;
+
+    protected readonly events = new Map<EventId, { streamId: StreamId; message: JSONRPCMessage }>();
+    protected readonly limit: number;
+    protected readonly logger?: Logger;
+
+    constructor(limit: number = LruEventStore.DEFAULT_LIMIT, logger?: Logger) {
+        if (limit < 1) {
+            throw new Error(`LruEventStore limit must be >= 1, got ${limit}`);
+        }
+        this.limit = limit;
+        this.logger = logger;
+    }
+
+    /** Current event count. Exposed for tests. */
+    get size(): number {
+        return this.events.size;
+    }
+
+    async storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId> {
+        // Format: `<streamId>_<unixMs>_<8-char-base36-random>`. The leading `streamId` lets
+        // `replayEventsAfter` recover the stream via `split('_')[0]` without a side table; the
+        // timestamp + random suffix make ids globally unique across concurrent emits.
+        const eventId = `${streamId}_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
+        this.events.set(eventId, { streamId, message });
+        if (this.events.size > this.limit) {
+            const oldest = this.events.keys().next().value;
+            if (oldest !== undefined) {
+                this.events.delete(oldest);
+            }
+        }
+        return eventId;
+    }
+
+    async replayEventsAfter(
+        lastEventId: EventId,
+        { send }: { send: (eventId: EventId, message: JSONRPCMessage) => Promise<void> }
+    ): Promise<StreamId> {
+        if (!lastEventId) {
+            return '';
+        }
+        if (!this.events.has(lastEventId)) {
+            // Cap-eviction race: warn so adopters can tune `eventStoreLimit` upward.
+            this.logger?.warn(
+                `[LruEventStore] Replay miss for last-event-id '${lastEventId}'. ` +
+                    `Cap is ${this.limit}; consider increasing \`eventStoreLimit\` if this fires under normal load.`
+            );
+            return '';
+        }
+        const streamId = lastEventId.split('_')[0];
+        if (!streamId) {
+            return '';
+        }
+
+        // Map iteration is insertion-order — equivalent to the SDK example's `localeCompare`
+        // sort under our id format, but cheaper and not dependent on the lexicographic-vs-
+        // chronological coincidence of the timestamp segment.
+        let foundLast = false;
+        for (const [eventId, { streamId: evtStreamId, message }] of this.events) {
+            if (evtStreamId !== streamId) {
+                continue;
+            }
+            if (eventId === lastEventId) {
+                foundLast = true;
+                continue;
+            }
+            if (foundLast) {
+                await send(eventId, message);
+            }
+        }
+        return streamId;
+    }
+}