@eclipse-glsp/server-mcp 2.8.0-next.0 → 2.8.0-next.10

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

@@ -1,231 +0,0 @@
-/********************************************************************************
- * 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/);
-    });
-});

package/src/common/server/mcp-handler-shared.spec.ts

@@ -1,53 +0,0 @@
-/********************************************************************************
- * 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 { ClientSessionManager } from '@eclipse-glsp/server';
-import { expect } from 'chai';
-import { McpToolError, resolveActiveSessionId } from './mcp-handler-shared';
-
-function stubSessionManager(sessionIds: string[]): ClientSessionManager {
-    return { getSessions: () => sessionIds.map(id => ({ id })) } as unknown as ClientSessionManager;
-}
-
-describe('resolveActiveSessionId', () => {
-    it('returns the explicit session id when it matches an open session', () => {
-        const result = resolveActiveSessionId(stubSessionManager(['alpha', 'beta']), 'alpha');
-        expect(result).to.equal('alpha');
-    });
-
-    it('defaults to the only open session when sessionId is omitted', () => {
-        const result = resolveActiveSessionId(stubSessionManager(['solo']), undefined);
-        expect(result).to.equal('solo');
-    });
-
-    it('throws McpToolError listing the open sessions when ambiguous', () => {
-        expect(() => resolveActiveSessionId(stubSessionManager(['session-a', 'session-b']), undefined)).to.throw(
-            McpToolError,
-            /Multiple sessions open.*session-a.*session-b/
-        );
-    });
-
-    it('throws McpToolError when no sessions are open', () => {
-        expect(() => resolveActiveSessionId(stubSessionManager([]), undefined)).to.throw(McpToolError, /No open diagram sessions/);
-    });
-
-    it('throws McpToolError when an explicit sessionId does not match any open session', () => {
-        expect(() => resolveActiveSessionId(stubSessionManager(['real-session']), 'ghost')).to.throw(
-            McpToolError,
-            /Unknown sessionId: ghost/
-        );
-    });
-});

package/src/common/server/mcp-id-alias-service.spec.ts

@@ -1,106 +0,0 @@
-/********************************************************************************
- * 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 { expect } from 'chai';
-import { DefaultMcpIdAliasService, NullMcpIdAliasService } from './mcp-id-alias-service';
-
-describe('DefaultMcpIdAliasService', () => {
-    it('returns the same alias on repeated calls with the same id (round-trip stability)', () => {
-        const service = new DefaultMcpIdAliasService();
-
-        const aliasA = service.alias('uuid-a');
-        const aliasA2 = service.alias('uuid-a');
-        const aliasB = service.alias('uuid-b');
-
-        expect(aliasA).to.equal(aliasA2);
-        expect(aliasA).to.not.equal(aliasB);
-        // Aliases are integer strings, starting at "1".
-        expect(aliasA).to.match(/^\d+$/);
-        expect(aliasB).to.match(/^\d+$/);
-    });
-
-    it('lookup(alias) returns the original id (round-trip)', () => {
-        const service = new DefaultMcpIdAliasService();
-
-        const alias = service.alias('uuid-foo');
-        expect(service.lookup(alias)).to.equal('uuid-foo');
-    });
-
-    it('lookup(unknown) returns the input verbatim (best-effort fallback)', () => {
-        const service = new DefaultMcpIdAliasService();
-
-        // Unknown ids may come from manual user input, copy-paste, or earlier server-side
-        // state. The service passes them through; downstream existence checks decide.
-        expect(service.lookup('never-issued')).to.equal('never-issued');
-    });
-
-    it('skips alias candidates that collide with a known real id (no shadowing)', () => {
-        // Regression: pre-fix, alias() always handed out sequential integers starting at "1".
-        // A model element whose actual id was "1" would then be shadowed — `lookup("1")`
-        // resolved to the *aliased* real id rather than passing through to the real "1".
-        // The service now records every real id seen via alias() and skips counter values
-        // that would collide.
-        const service = new DefaultMcpIdAliasService();
-        const aliasOf1 = service.alias('1');
-        const aliasOfX = service.alias('uuid-other');
-
-        expect(aliasOf1).to.not.equal('1');
-        expect(aliasOfX).to.not.equal('1');
-        expect(service.lookup('1')).to.equal('1');
-        expect(service.lookup(aliasOf1)).to.equal('1');
-        expect(service.lookup(aliasOfX)).to.equal('uuid-other');
-
-        // Multiple pre-known real ids: every issued alias is outside the known-real set.
-        const service2 = new DefaultMcpIdAliasService();
-        const knownReals = ['1', '2', '3'];
-        knownReals.forEach(id => service2.alias(id));
-        const fresh = service2.alias('uuid-fresh');
-        expect(knownReals).to.not.include(fresh);
-    });
-
-    it('keeps independent counters and maps across separate instances (per-session isolation)', () => {
-        // Adopters get one instance per GLSP session; aliases must not bleed between sessions.
-        const sessionA = new DefaultMcpIdAliasService();
-        const sessionB = new DefaultMcpIdAliasService();
-
-        const aliasA1 = sessionA.alias('uuid-x');
-        const aliasA2 = sessionA.alias('uuid-y');
-        const aliasB1 = sessionB.alias('uuid-z');
-
-        // Counters are independent: B's first alias is "1", same as A's first.
-        expect(aliasA1).to.equal('1');
-        expect(aliasA2).to.equal('2');
-        expect(aliasB1).to.equal('1');
-
-        // Bleed-isolation: alias "1" in B resolves to uuid-z, NOT to uuid-x (A's "1").
-        expect(sessionA.lookup('1')).to.equal('uuid-x');
-        expect(sessionB.lookup('1')).to.equal('uuid-z');
-
-        // Unknown ids in either session fall through to the input verbatim.
-        expect(sessionA.lookup('3')).to.equal('3');
-        expect(sessionB.lookup('2')).to.equal('2');
-    });
-});
-
-describe('NullMcpIdAliasService', () => {
-    it('alias and lookup return the argument unchanged', () => {
-        const service = new NullMcpIdAliasService();
-
-        expect(service.alias('uuid-foo')).to.equal('uuid-foo');
-        expect(service.lookup('uuid-foo')).to.equal('uuid-foo');
-        expect(service.lookup('never-seen')).to.equal('never-seen');
-    });
-});

package/src/common/server/mcp-log-level-registry.spec.ts

@@ -1,75 +0,0 @@
-/********************************************************************************
- * 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 { expect } from 'chai';
-import { DefaultMcpLogLevelRegistry, passesLogThreshold } from './mcp-log-level-registry';
-
-describe('passesLogThreshold (G4 severity gate)', () => {
-    it('passes a level whose severity is at or above the threshold (RFC 5424: lower number = more severe)', () => {
-        // Threshold 'warning' (4) keeps emergency..warning, drops notice..debug.
-        expect(passesLogThreshold('emergency', 'warning')).to.equal(true);
-        expect(passesLogThreshold('error', 'warning')).to.equal(true);
-        expect(passesLogThreshold('warning', 'warning')).to.equal(true);
-        expect(passesLogThreshold('notice', 'warning')).to.equal(false);
-        expect(passesLogThreshold('info', 'warning')).to.equal(false);
-        expect(passesLogThreshold('debug', 'warning')).to.equal(false);
-    });
-
-    it('passes everything when the threshold is debug (the default)', () => {
-        for (const level of ['emergency', 'alert', 'critical', 'error', 'warning', 'notice', 'info', 'debug'] as const) {
-            expect(passesLogThreshold(level, 'debug')).to.equal(true);
-        }
-    });
-
-    it('passes only emergency when the threshold is emergency', () => {
-        expect(passesLogThreshold('emergency', 'emergency')).to.equal(true);
-        expect(passesLogThreshold('alert', 'emergency')).to.equal(false);
-        expect(passesLogThreshold('debug', 'emergency')).to.equal(false);
-    });
-});
-
-describe('DefaultMcpLogLevelRegistry', () => {
-    it('returns the default level for an unknown session id', () => {
-        const registry = new DefaultMcpLogLevelRegistry();
-        expect(registry.getLevel('never-set')).to.equal(DefaultMcpLogLevelRegistry.DEFAULT_LEVEL);
-    });
-
-    it('returns the default level when sessionId is undefined (out-of-band logger calls)', () => {
-        const registry = new DefaultMcpLogLevelRegistry();
-        expect(registry.getLevel(undefined)).to.equal(DefaultMcpLogLevelRegistry.DEFAULT_LEVEL);
-    });
-
-    it('persists the most recent setLevel value per session and isolates across sessions', () => {
-        const registry = new DefaultMcpLogLevelRegistry();
-        registry.setLevel('A', 'warning');
-        registry.setLevel('B', 'error');
-        expect(registry.getLevel('A')).to.equal('warning');
-        expect(registry.getLevel('B')).to.equal('error');
-
-        registry.setLevel('A', 'info');
-        expect(registry.getLevel('A')).to.equal('info');
-        expect(registry.getLevel('B')).to.equal('error');
-    });
-
-    it('clear(sessionId) drops the entry so a recycled session id starts at the default', () => {
-        const registry = new DefaultMcpLogLevelRegistry();
-        registry.setLevel('reused', 'error');
-        expect(registry.getLevel('reused')).to.equal('error');
-
-        registry.clear('reused');
-        expect(registry.getLevel('reused')).to.equal(DefaultMcpLogLevelRegistry.DEFAULT_LEVEL);
-    });
-});