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

package/src/{tools → common/tools}/handlers/delete-elements-mcp-tool-handler.ts

@@ -18,7 +18,7 @@ import { DeleteElementOperation } from '@eclipse-glsp/server';
 import { injectable } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolResult } from '../../server/mcp-handler-shared';
-import { ElementIdentitySchema, McpDiagramScopedInputSchema, elementIds } from '../../server/mcp-input-schemas';
+import { ElementIdentitySchema, McpDiagramScopedInputSchema, dispatchedCommands, elementIds } from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 
 export const DeleteElementsInputSchema = McpDiagramScopedInputSchema.extend({ elementIds });
@@ -35,7 +35,8 @@ export const DeleteElementsOutputSchema = z.object({
         .int()
         .describe(
             'Total number of elements removed from the model. Higher than `deletedElements.length` when dependents (e.g. edges) are auto-deleted.'
-        )
+        ),
+    dispatchedCommands
 });
 
 @injectable()
@@ -63,7 +64,8 @@ export class DeleteElementsMcpToolHandler extends OperationMcpDiagramToolHandler
         const deletedCount = beforeCount - this.modelState.index.allIds().length;
         return this.success(`Successfully deleted ${deletedCount} element(s) (including dependents)`, {
             deletedElements,
-            deletedCount
+            deletedCount,
+            dispatchedCommands: 1
         });
     }
 }

package/src/{tools → common/tools}/handlers/layout-mcp-tool-handler.ts

@@ -18,14 +18,15 @@ import { LayoutEngine, LayoutOperation } from '@eclipse-glsp/server';
 import { inject, injectable, optional } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolResult } from '../../server/mcp-handler-shared';
-import { McpDiagramScopedInputSchema } from '../../server/mcp-input-schemas';
+import { McpDiagramScopedInputSchema, dispatchedCommands } from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 
 export const LayoutInputSchema = McpDiagramScopedInputSchema;
 export type LayoutInput = z.infer<typeof LayoutInputSchema>;
 
 export const LayoutOutputSchema = z.object({
-    applied: z.boolean().describe('Always true on success — surfaced for parity with other operations.')
+    applied: z.boolean().describe('Always true on success — surfaced for parity with other operations.'),
+    dispatchedCommands
 });
 
 /** Not registered by default: requires an adopter-supplied `LayoutEngine` to bind, which only some GLSP servers ship. */
@@ -53,6 +54,6 @@ export class LayoutMcpToolHandler extends OperationMcpDiagramToolHandler<LayoutI
 
     protected async createResult(_params: LayoutInput): Promise<McpToolResult> {
         await this.actionDispatcher.dispatch(LayoutOperation.create());
-        return this.success('Automatic layout applied', { applied: true });
+        return this.success('Automatic layout applied', { applied: true, dispatchedCommands: 1 });
     }
 }

package/src/{tools → common/tools}/handlers/modify-edges-mcp-tool-handler.ts

@@ -18,7 +18,13 @@ import { ChangeRoutingPointsOperation, GEdge, ReconnectEdgeOperation } from '@ec
 import { injectable } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolError, McpToolResult } from '../../server/mcp-handler-shared';
-import { ElementIdentitySchema, McpDiagramScopedInputSchema, elementId as elementIdSchema, position } from '../../server/mcp-input-schemas';
+import {
+    ElementIdentitySchema,
+    McpDiagramScopedInputSchema,
+    dispatchedCommands,
+    elementId as elementIdSchema,
+    position
+} from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 import { formatNoticeList } from '../../util/mcp-util';
 
@@ -46,7 +52,7 @@ export type ModifyEdgesInput = z.infer<typeof ModifyEdgesInputSchema>;
 
 export const ModifyEdgesOutputSchema = z.object({
     modifiedEdges: z.array(ElementIdentitySchema).describe('Identity of each edge whose change request was dispatched.'),
-    dispatchedCommands: z.number().int().describe('Number of underlying GLSP operations dispatched.'),
+    dispatchedCommands,
     errors: z.array(z.string()).describe('Per-input failure messages; absent or empty when every input succeeded.')
 });
 

package/src/{tools → common/tools}/handlers/modify-nodes-mcp-tool-handler.ts

@@ -18,7 +18,13 @@ import { ApplyLabelEditOperation, ChangeBoundsOperation, GEdge, GShapeElement }
 import { injectable } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolError, McpToolResult } from '../../server/mcp-handler-shared';
-import { ElementIdentitySchema, McpDiagramScopedInputSchema, elementId, position } from '../../server/mcp-input-schemas';
+import {
+    ElementIdentitySchema,
+    McpDiagramScopedInputSchema,
+    dispatchedCommands,
+    elementId,
+    position
+} from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 import { formatNoticeList } from '../../util/mcp-util';
 
@@ -48,7 +54,7 @@ export const ModifyNodesOutputSchema = z.object({
     modifiedNodes: z
         .array(ElementIdentitySchema)
         .describe('Identity of each node whose change request was dispatched (post-modification labels).'),
-    dispatchedCommands: z.number().int().describe('Number of underlying GLSP operations dispatched (a single change may yield several).'),
+    dispatchedCommands,
     warnings: z
         .array(z.string())
         .describe(

package/src/node/index.ts

@@ -0,0 +1,20 @@
+/********************************************************************************
+ * 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 './modules/node-mcp-server-module';
+export * from './reexport';
+export * from './server/node-mcp-request-context';
+export * from './server/node-mcp-server-launcher';

package/src/node/modules/node-mcp-server-module.ts

@@ -0,0 +1,56 @@
+/********************************************************************************
+ * 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 { BindingTarget } from '@eclipse-glsp/server';
+import { AbstractMcpServerModule, DEFAULT_MCP_OPTIONS } from '../../common/modules/abstract-mcp-server-module';
+import { AbstractMcpServerLauncher } from '../../common/server/abstract-mcp-server-launcher';
+import { McpServerDefaults } from '../../common/server/mcp-options';
+import { McpRequestContext } from '../../common/server/mcp-request-context';
+import { NodeMcpServerLauncher } from '../server/node-mcp-server-launcher';
+import { NodeMcpRequestContext } from '../server/node-mcp-request-context';
+
+/**
+ * Default {@link AbstractMcpServerModule} entry point for Node hosts. Ships GLSP-default option
+ * values (see {@link DEFAULT_OPTIONS}) on top of the abstract module's hook defaults, and binds
+ * the Node-flavored {@link NodeMcpServerLauncher} + {@link NodeMcpRequestContext}. Adopter-provided
+ * overrides via the constructor merge on top.
+ *
+ * @experimental The MCP integration is under active development. Option names, schema shapes,
+ * and handler contracts MAY change in minor releases until the feature graduates from
+ * experimental status.
+ */
+export class NodeMcpServerModule extends AbstractMcpServerModule {
+    static readonly DEFAULT_OPTIONS: McpServerDefaults = {
+        ...DEFAULT_MCP_OPTIONS,
+        host: '127.0.0.1',
+        allowedHosts: ['127.0.0.1', 'localhost']
+        // `allowedOrigins` deliberately undefined: accept absent Origin (typical for desktop-IDE
+        // MCP clients) and rely on Host validation to gate DNS-rebinding. Adopters whose
+        // deployment is browser-fronted set this explicitly to their frontend's origin.
+    };
+
+    constructor(overrides: McpServerDefaults = {}) {
+        super({ ...NodeMcpServerModule.DEFAULT_OPTIONS, ...overrides });
+    }
+
+    protected override bindMcpServerLauncher(): BindingTarget<AbstractMcpServerLauncher> {
+        return NodeMcpServerLauncher;
+    }
+
+    protected override bindMcpRequestContext(): BindingTarget<McpRequestContext> {
+        return NodeMcpRequestContext;
+    }
+}

package/src/node/reexport.ts

@@ -0,0 +1,16 @@
+/********************************************************************************
+ * 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 '../common';

package/src/node/server/mcp-http-transport-e2e.spec.ts

@@ -0,0 +1,297 @@
+/********************************************************************************
+ * 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, InitializeParameters, InitializeResult, Logger, NullLogger } from '@eclipse-glsp/server';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import * as z from 'zod/v4';
+import { FullMcpServerConfiguration } from '../../common/server/abstract-mcp-server-launcher';
+import { DefaultGLSPMcpServer, GLSPMcpServerFactory } from '../../common/server/glsp-mcp-server';
+import { McpDiagramHandlerDispatcher } from '../../common/server/mcp-diagram-handler-dispatcher';
+import { DefaultMcpLogLevelRegistry, McpLogLevelRegistry } from '../../common/server/mcp-log-level-registry';
+import { McpServerDefaults, McpServerOptions } from '../../common/server/mcp-options';
+import { NodeMcpServerLauncher } from './node-mcp-server-launcher';
+import { rawHttpRequest } from './raw-http.spec';
+
+class StubDispatcher implements McpDiagramHandlerDispatcher {
+    harvest(): void {
+        /* no-op */
+    }
+    reset(): void {
+        /* no-op */
+    }
+    hasDiagramTools(): boolean {
+        return false;
+    }
+    hasDiagramResources(): boolean {
+        return false;
+    }
+    hasDiagramPrompts(): boolean {
+        return false;
+    }
+    registerAll(): void {
+        /* no-op */
+    }
+}
+
+class StubClientSessionManager {
+    addListener(): boolean {
+        return true;
+    }
+    removeListener(): boolean {
+        return true;
+    }
+    getSessions(): unknown[] {
+        return [];
+    }
+    getSession(): unknown {
+        return undefined;
+    }
+    getSessionsByType(): unknown[] {
+        return [];
+    }
+}
+
+/**
+ * Test subclass that registers a single `echo` tool on every fresh GLSP MCP server. We use this
+ * to drive a real MCP SDK client through a full handshake without depending on the workflow
+ * server's diagram handler stack.
+ */
+class EchoLauncher extends NodeMcpServerLauncher {
+    protected override createGlspMcpServer(config: FullMcpServerConfiguration): DefaultGLSPMcpServer {
+        const server = super.createGlspMcpServer(config) as DefaultGLSPMcpServer;
+        server.registerTool(
+            'echo',
+            { description: 'Returns the supplied message verbatim.', inputSchema: { message: z.string() } },
+            async ({ message }) => ({ content: [{ type: 'text', text: message }] })
+        );
+        return server;
+    }
+}
+
+function buildLauncher(optionValues: McpServerOptions['values'] = {}): EchoLauncher {
+    const container = new Container();
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new NullLogger());
+            const opts = new McpServerOptions();
+            opts.values = optionValues;
+            bind(McpServerOptions).toConstantValue(opts);
+            bind(McpServerDefaults).toConstantValue(optionValues);
+            bind(McpDiagramHandlerDispatcher).toConstantValue(new StubDispatcher());
+            bind(McpLogLevelRegistry).to(DefaultMcpLogLevelRegistry).inSingletonScope();
+            bind(ClientSessionManager).toConstantValue(new StubClientSessionManager());
+            const factory: GLSPMcpServerFactory = (mcpServer, options) => new DefaultGLSPMcpServer(mcpServer, options, new NullLogger());
+            bind(GLSPMcpServerFactory).toConstantValue(factory);
+            bind(EchoLauncher).toSelf().inSingletonScope();
+        })
+    );
+    return container.get(EchoLauncher);
+}
+
+async function startLauncher(
+    launcher: EchoLauncher,
+    options: { port?: number; host?: string; route?: string; allowedHosts?: string[]; allowedOrigins?: string[] } = {}
+): Promise<string> {
+    const params: InitializeParameters = {
+        applicationId: 'spec-app',
+        clientSessionId: 'spec-session',
+        protocolVersion: '1.0.0',
+        args: {},
+        mcpServer: {
+            port: options.port ?? 0,
+            route: options.route ?? '/mcp',
+            name: 'spec',
+            options: {}
+        }
+    } as unknown as InitializeParameters;
+    // Inject the deploy-only fields directly on the merged options holder.
+    launcher['mcpDefaults'] = {
+        host: options.host ?? '127.0.0.1',
+        allowedHosts: options.allowedHosts,
+        allowedOrigins: options.allowedOrigins
+    };
+    const baseResult: InitializeResult = { protocolVersion: '1.0.0', serverActions: {} } as unknown as InitializeResult;
+    const result = await launcher.initializeServer({} as never, params, baseResult);
+    const url = (result as unknown as { mcpServer?: { url?: string } }).mcpServer?.url;
+    if (!url) throw new Error('launcher did not announce a URL');
+    return url;
+}
+
+/**
+ * End-to-end smoke test: boot the launcher (which spins up the Hono-on-Node listener),
+ * connect a real SDK MCP client over Streamable HTTP, and exercise a tool round-trip (`echo`).
+ */
+describe('NodeMcpServerLauncher (e2e — real MCP SDK client over HTTP)', () => {
+    let launcher: EchoLauncher | undefined;
+    let client: Client | undefined;
+
+    async function safeClose(target: Client | undefined): Promise<void> {
+        if (!target) return;
+        try {
+            await target.close();
+        } catch {
+            /* ignore — best effort */
+        }
+    }
+
+    afterEach(async () => {
+        await safeClose(client);
+        client = undefined;
+        launcher?.dispose();
+        launcher = undefined;
+    });
+
+    it('round-trips tools/list and tools/call against a registered echo tool', async () => {
+        launcher = buildLauncher();
+        const url = await startLauncher(launcher);
+        expect(url, 'launcher must announce a URL after initializeServer').to.be.a('string');
+
+        client = new Client({ name: 'wn-058-test-client', version: '1.0.0' });
+        await client.connect(new StreamableHTTPClientTransport(new URL(url)));
+
+        const tools = await client.listTools();
+        expect(tools.tools.map(tool => tool.name)).to.include('echo');
+
+        const result = await client.callTool({ name: 'echo', arguments: { message: 'hello GLSP' } });
+        expect(result.isError).to.not.equal(true);
+        expect(result.content).to.have.lengthOf(1);
+        const [block] = result.content as Array<{ type: string; text?: string }>;
+        expect(block.type).to.equal('text');
+        expect(block.text).to.equal('hello GLSP');
+    });
+
+    it('DELETE /mcp terminates the session; subsequent POSTs with the same id return 404 (§ #5)', async () => {
+        launcher = buildLauncher();
+        const url = await startLauncher(launcher);
+
+        client = new Client({ name: 'delete-smoke-test', version: '1.0.0' });
+        const clientTransport = new StreamableHTTPClientTransport(new URL(url));
+        await client.connect(clientTransport);
+        const sessionId = clientTransport.sessionId;
+        expect(sessionId, 'SDK transport should expose the minted session id after initialize').to.be.a('string');
+
+        const port = Number(new URL(url).port);
+
+        const deleteRes = await rawHttpRequest(port, 'DELETE', { 'mcp-session-id': sessionId! });
+        expect(deleteRes.status, 'DELETE should succeed for an active session').to.be.lessThan(300);
+
+        const followUp = await rawHttpRequest(
+            port,
+            'POST',
+            { 'mcp-session-id': sessionId! },
+            { jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }
+        );
+        expect(followUp.status).to.equal(404);
+        const payload = JSON.parse(followUp.body);
+        expect(payload.error.code).to.equal(-32001);
+    });
+});
+
+describe('NodeMcpServerLauncher (raw HTTP wire validation)', () => {
+    let launcher: EchoLauncher | undefined;
+
+    afterEach(() => {
+        launcher?.dispose();
+        launcher = undefined;
+    });
+
+    async function startWith(values: McpServerOptions['values']): Promise<number> {
+        launcher = buildLauncher(values);
+        const url = await startLauncher(launcher, { allowedHosts: values.allowedHosts, allowedOrigins: values.allowedOrigins });
+        return Number(new URL(url).port);
+    }
+
+    it('binds an HTTP listener on a resolvable loopback port', async () => {
+        launcher = buildLauncher();
+        const url = await startLauncher(launcher);
+        expect(url).to.match(/^http:\/\/(127\.0\.0\.1|localhost):\d+\/mcp$/);
+    });
+
+    it('rejects a non-initialize POST without an Mcp-Session-Id header with 400 (§ #2)', async () => {
+        const port = await startWith({});
+        const res = await rawHttpRequest(port, 'POST', {}, { jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} });
+        expect(res.status).to.equal(400);
+        const payload = JSON.parse(res.body);
+        expect(payload.error.code).to.equal(-32000);
+        expect(payload.error.message).to.match(/No valid session ID/);
+    });
+
+    it('rejects a POST with an unknown Mcp-Session-Id with 404 (§ #3)', async () => {
+        const port = await startWith({});
+        const res = await rawHttpRequest(
+            port,
+            'POST',
+            { 'mcp-session-id': 'no-such-session' },
+            { jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }
+        );
+        expect(res.status).to.equal(404);
+        const payload = JSON.parse(res.body);
+        expect(payload.error.code).to.equal(-32001);
+    });
+
+    it('rejects a non-initialize POST whose MCP-Protocol-Version is unsupported with HTTP 400', async () => {
+        const port = await startWith({});
+        const res = await rawHttpRequest(
+            port,
+            'POST',
+            { 'mcp-session-id': 'doesnt-matter', 'mcp-protocol-version': '1999-01-01' },
+            { jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }
+        );
+        expect(res.status).to.equal(400);
+        const payload = JSON.parse(res.body);
+        expect(payload.error.message).to.match(/Unsupported MCP-Protocol-Version/);
+    });
+
+    it('rejects requests with a Host header outside the allowlist', async () => {
+        const port = await startWith({ allowedHosts: ['127.0.0.1', 'localhost'] });
+        // POST init body so we go past session-id validation into the SDK transport's host check.
+        const res = await rawHttpRequest(
+            port,
+            'POST',
+            { Host: 'evil.example' },
+            {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'initialize',
+                params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'x', version: '1' } }
+            }
+        );
+        expect(res.status).to.equal(403);
+    });
+
+    it('rejects start when the requested port is already in use with an actionable error', async () => {
+        const firstLauncher = buildLauncher();
+        const url = await startLauncher(firstLauncher);
+        const taken = Number(new URL(url).port);
+        const secondLauncher = buildLauncher();
+        let error: Error | undefined;
+        try {
+            await startLauncher(secondLauncher, { port: taken });
+        } catch (err: unknown) {
+            error = err as Error;
+        } finally {
+            firstLauncher.dispose();
+            secondLauncher.dispose();
+        }
+        expect(error, 'expected initializeServer to reject').to.not.equal(undefined);
+        expect(error!.message).to.match(/127\.0\.0\.1:\d+/);
+        expect(error!.message).to.include('mcpServer.port');
+        expect(error!.message).to.match(/already in use/);
+    });
+});

package/src/node/server/node-mcp-request-context.ts

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * 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 { AsyncLocalStorage } from 'async_hooks';
+import { injectable } from 'inversify';
+import { McpRequestContext, McpRequestExtra } from '../../common/server/mcp-request-context';
+
+/** {@link McpRequestContext} backed by native `AsyncLocalStorage`; frame survives across `await`. */
+@injectable()
+export class NodeMcpRequestContext implements McpRequestContext {
+    protected storage = new AsyncLocalStorage<McpRequestExtra>();
+
+    run<R>(extra: McpRequestExtra, callback: () => R): R {
+        return this.storage.run(extra, callback);
+    }
+
+    getStore(): McpRequestExtra | undefined {
+        return this.storage.getStore();
+    }
+}

package/src/{server/mcp-server-launcher.spec.ts → node/server/node-mcp-server-launcher.spec.ts}

@@ -16,10 +16,11 @@
 
 import { McpServerInitOptions } from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
-import { version as packageVersion } from '../../package.json';
-import { McpServerLauncher, SERVER_VERSION, assertLoopbackOrAcknowledged, isLoopbackHost, pickInitOptions } from './mcp-server-launcher';
+import { version as packageVersion } from '../../../package.json';
+import { SERVER_VERSION, pickInitOptions } from '../../common/server/abstract-mcp-server-launcher';
+import { NodeMcpServerLauncher, assertLoopbackOrAcknowledged, isLoopbackHost } from './node-mcp-server-launcher';
 
-describe('McpServerLauncher · SERVER_VERSION', () => {
+describe('NodeMcpServerLauncher · SERVER_VERSION', () => {
     it('matches the package.json version (no stale literal)', () => {
         // Regression guard: the launcher used to hard-code '1.0.0'. Pull from package.json so
         // adopters and MCP clients can tell builds apart via the `serverInfo.version` handshake
@@ -28,7 +29,7 @@ describe('McpServerLauncher · SERVER_VERSION', () => {
     });
 });
 
-describe('McpServerLauncher · buildCapabilities', () => {
+describe('NodeMcpServerLauncher · buildCapabilities', () => {
     /**
      * Sidestep DI: build a stub whose shape matches the fields `buildCapabilities` reads, then
      * invoke the prototype method against it. The method is protected, so we cast through.
@@ -54,7 +55,7 @@ describe('McpServerLauncher · buildCapabilities', () => {
                 hasDiagramResources: () => args.hasDiagramResources ?? false
             }
         };
-        const proto = McpServerLauncher.prototype as unknown as {
+        const proto = NodeMcpServerLauncher.prototype as unknown as {
             buildCapabilities(this: typeof stub, resourcesAsResources: boolean): Record<string, unknown>;
         };
         return proto.buildCapabilities.call(stub, resourcesAsResources);
@@ -97,7 +98,7 @@ describe('McpServerLauncher · buildCapabilities', () => {
     });
 });
 
-describe('McpServerLauncher · isLoopbackHost', () => {
+describe('NodeMcpServerLauncher · isLoopbackHost', () => {
     it('treats 127.0.0.0/8, localhost, and ::1 as loopback', () => {
         expect(isLoopbackHost('127.0.0.1')).to.equal(true);
         expect(isLoopbackHost('127.55.0.1')).to.equal(true);
@@ -114,7 +115,7 @@ describe('McpServerLauncher · isLoopbackHost', () => {
     });
 });
 
-describe('McpServerLauncher · assertLoopbackOrAcknowledged (auth footgun)', () => {
+describe('NodeMcpServerLauncher · assertLoopbackOrAcknowledged (auth footgun)', () => {
     it('passes silently for a loopback bind without acknowledgement', () => {
         expect(() => assertLoopbackOrAcknowledged('127.0.0.1', undefined)).to.not.throw();
         expect(() => assertLoopbackOrAcknowledged('localhost', undefined)).to.not.throw();
@@ -139,7 +140,17 @@ describe('McpServerLauncher · assertLoopbackOrAcknowledged (auth footgun)', ()
     });
 });
 
-describe('McpServerLauncher · pickInitOptions (deploy/init split — defense-in-depth)', () => {
+// Compile-time exhaustiveness check — fails the build if `McpServerInitOptions` grows or
+// shrinks while the `pickInitOptions` destructure doesn't follow.
+type _Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+function assertPickInitKeysExhaustive(
+    _: _Equal<keyof import('@eclipse-glsp/server').McpServerInitOptions, 'dataMode' | 'agentPersona' | 'eventStoreLimit'>
+): void {
+    /* type-only */
+}
+assertPickInitKeysExhaustive(true);
+
+describe('NodeMcpServerLauncher · pickInitOptions (deploy/init split — defense-in-depth)', () => {
     it('passes through every allowed init-side field unchanged', () => {
         const picked = pickInitOptions({ dataMode: 'resources', agentPersona: 'X', eventStoreLimit: 50 });
         expect(picked).to.deep.equal({ dataMode: 'resources', agentPersona: 'X', eventStoreLimit: 50 });