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

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;
+    }
+}

package/src/server/mcp-diagram-handler-dispatcher.spec.ts

@@ -0,0 +1,231 @@
+/********************************************************************************
+ * 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 { CallToolResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import { expect } from 'chai';
+import { GLSPMcpServer } from './glsp-mcp-server';
+import { DefaultMcpDiagramHandlerDispatcher, DiagramTypeCatalog } from './mcp-diagram-handler-dispatcher';
+
+/**
+ * Tests the SDK-callback dispatch error path covered by `runWithToolErrorEnvelope`. The
+ * concern is that pre-handler routing errors (missing/unknown sessionId, unknown handler name)
+ * that the launcher's tool path `throw McpToolError` are converted into `{ isError: true }` tool
+ * results by the wrap, instead of bubbling up as JSON-RPC `-32603 Internal error`.
+ *
+ * The prompt path is intentionally NOT wrapped — prompt errors propagate as JSON-RPC errors per
+ * MCP spec semantics. This test pins that asymmetry too.
+ */
+
+type ToolCallback = (params: unknown, extra: unknown) => Promise<CallToolResult>;
+type PromptCallback = (args: unknown, extra: unknown) => Promise<unknown>;
+type StaticResourceCallback = (uri: URL, extra: unknown) => Promise<ReadResourceResult>;
+
+class CapturingMcpServer {
+    readonly tools = new Map<string, ToolCallback>();
+    readonly prompts = new Map<string, PromptCallback>();
+    readonly staticResources = new Map<string, StaticResourceCallback>();
+
+    registerTool(name: string, _config: unknown, callback: ToolCallback): unknown {
+        this.tools.set(name, callback);
+        return undefined;
+    }
+
+    registerPrompt(name: string, _config: unknown, callback: PromptCallback): unknown {
+        this.prompts.set(name, callback);
+        return undefined;
+    }
+
+    registerResource(name: string, uriOrTemplate: unknown, _config: unknown, callback: unknown): unknown {
+        if (typeof uriOrTemplate === 'string') {
+            this.staticResources.set(name, callback as StaticResourceCallback);
+        }
+        return undefined;
+    }
+}
+
+function makeDispatcher(
+    catalog: DiagramTypeCatalog,
+    sessions: Array<{ id: string; container?: unknown; diagramType?: string }> = []
+): DefaultMcpDiagramHandlerDispatcher {
+    const dispatcher = new DefaultMcpDiagramHandlerDispatcher();
+    (dispatcher as unknown as { diagramCatalogs: DiagramTypeCatalog[] }).diagramCatalogs = [catalog];
+    (dispatcher as unknown as { clientSessionManager: unknown }).clientSessionManager = {
+        getSessions: () => sessions,
+        getSession: (id: string) => sessions.find(session => session.id === id)
+    };
+    return dispatcher;
+}
+
+class FakeToolHandlerCtor {
+    name = 'fake-tool';
+    title = 'Fake';
+    description = 'A test tool';
+    inputSchema = { strict: () => ({}) };
+    toRegistrationConfig(): unknown {
+        return { title: this.title, description: this.description, inputSchema: {} };
+    }
+}
+
+class FakePromptHandlerCtor {
+    name = 'fake-prompt';
+    title = 'FakePrompt';
+    description = 'A test prompt';
+    toRegistrationConfig(): unknown {
+        return { title: this.title, description: this.description };
+    }
+}
+
+class FakeResourceAsToolHandlerCtor {
+    name = 'fake-resource';
+    title = 'FakeResource';
+    description = 'A test resource exposed as tool';
+    mimeType = 'text/plain';
+    uri = 'glsp://static/fake';
+    toolAlternativeInputSchema = { strict: () => ({}) };
+    toolAlternativeOutputSchema = undefined;
+    toAnnotations(): undefined {
+        return undefined;
+    }
+}
+
+class FakeStaticResourceHandlerCtor {
+    name = 'fake-static-resource';
+    title = 'FakeStatic';
+    description = 'A test static-URI resource';
+    mimeType = 'text/plain';
+    uri = 'glsp://static/fake';
+    toAnnotations(): undefined {
+        return undefined;
+    }
+}
+
+describe('DefaultMcpDiagramHandlerDispatcher · SDK-callback dispatch error envelope', () => {
+    it('tool callback returns isError envelope when sessionId is missing', async () => {
+        const dispatcher = makeDispatcher({
+            diagramType: 'test',
+            toolConstructors: [FakeToolHandlerCtor as unknown as DiagramTypeCatalog['toolConstructors'][number]],
+            resourceConstructors: [],
+            promptConstructors: []
+        });
+        const captured = new CapturingMcpServer();
+        dispatcher.registerAll(captured as unknown as GLSPMcpServer, false);
+
+        const result = await captured.tools.get('fake-tool')!({}, {});
+        expect(result.isError).to.equal(true);
+        expect((result.content as Array<{ text: string }>)[0].text).to.match(/sessionId/);
+    });
+
+    it('tool callback returns isError envelope when sessionId is unknown', async () => {
+        const dispatcher = makeDispatcher(
+            {
+                diagramType: 'test',
+                toolConstructors: [FakeToolHandlerCtor as unknown as DiagramTypeCatalog['toolConstructors'][number]],
+                resourceConstructors: [],
+                promptConstructors: []
+            },
+            [] // no open sessions
+        );
+        const captured = new CapturingMcpServer();
+        dispatcher.registerAll(captured as unknown as GLSPMcpServer, false);
+
+        const result = await captured.tools.get('fake-tool')!({ sessionId: 'unknown-glsp-id' }, {});
+        expect(result.isError).to.equal(true);
+        expect((result.content as Array<{ text: string }>)[0].text).to.match(/Session not found/);
+    });
+
+    it('tool callback returns isError envelope when registered handler is absent for the session', async () => {
+        const sessionContainer = {
+            get: () => ({
+                get: () => undefined // registry returns no handler
+            })
+        };
+        const dispatcher = makeDispatcher(
+            {
+                diagramType: 'test',
+                toolConstructors: [FakeToolHandlerCtor as unknown as DiagramTypeCatalog['toolConstructors'][number]],
+                resourceConstructors: [],
+                promptConstructors: []
+            },
+            [{ id: 'session-1', container: sessionContainer, diagramType: 'test' }]
+        );
+        const captured = new CapturingMcpServer();
+        dispatcher.registerAll(captured as unknown as GLSPMcpServer, false);
+
+        const result = await captured.tools.get('fake-tool')!({ sessionId: 'session-1' }, {});
+        expect(result.isError).to.equal(true);
+        expect((result.content as Array<{ text: string }>)[0].text).to.match(/No tool handler/);
+    });
+
+    it('resource-as-tool callback returns isError envelope when sessionId is missing', async () => {
+        const dispatcher = makeDispatcher({
+            diagramType: 'test',
+            toolConstructors: [],
+            resourceConstructors: [FakeResourceAsToolHandlerCtor as unknown as DiagramTypeCatalog['resourceConstructors'][number]],
+            promptConstructors: []
+        });
+        const captured = new CapturingMcpServer();
+        // dataMode='tools' (resourcesAsResources=false) → resource registers as tool fallback.
+        dispatcher.registerAll(captured as unknown as GLSPMcpServer, false);
+
+        const result = await captured.tools.get('fake-resource')!({}, {});
+        expect(result.isError).to.equal(true);
+        expect((result.content as Array<{ text: string }>)[0].text).to.match(/sessionId/);
+    });
+
+    it('static-URI resource read throws McpToolError when no GLSP session is open', async () => {
+        const dispatcher = makeDispatcher(
+            {
+                diagramType: 'test',
+                toolConstructors: [],
+                resourceConstructors: [FakeStaticResourceHandlerCtor as unknown as DiagramTypeCatalog['resourceConstructors'][number]],
+                promptConstructors: []
+            },
+            [] // no open sessions
+        );
+        const captured = new CapturingMcpServer();
+        // dataMode='resources' (resourcesAsResources=true) → resource registers as URI-addressable resource.
+        dispatcher.registerAll(captured as unknown as GLSPMcpServer, true);
+
+        let rejection: unknown;
+        try {
+            await captured.staticResources.get('fake-static-resource')!(new URL('glsp://static/fake'), {});
+        } catch (err: unknown) {
+            rejection = err;
+        }
+        expect(rejection).to.exist;
+        expect((rejection as Error).message).to.match(/No open GLSP session/);
+    });
+
+    it('prompt callback rejects with McpToolError when sessionId is missing (no envelope wrap — by design)', async () => {
+        const dispatcher = makeDispatcher({
+            diagramType: 'test',
+            toolConstructors: [],
+            resourceConstructors: [],
+            promptConstructors: [FakePromptHandlerCtor as unknown as DiagramTypeCatalog['promptConstructors'][number]]
+        });
+        const captured = new CapturingMcpServer();
+        dispatcher.registerAll(captured as unknown as GLSPMcpServer, false);
+
+        let rejection: unknown;
+        try {
+            await captured.prompts.get('fake-prompt')!({}, {});
+        } catch (err: unknown) {
+            rejection = err;
+        }
+        expect(rejection).to.exist;
+        expect((rejection as Error).message).to.match(/sessionId/);
+    });
+});