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

package/src/server/mcp-label-provider.ts

@@ -0,0 +1,52 @@
+/********************************************************************************
+ * 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 { GLabel, GModelElement } from '@eclipse-glsp/server';
+import { injectable } from 'inversify';
+
+export const McpLabelProvider = Symbol('McpLabelProvider');
+
+/**
+ * Locates the {@link GLabel} that primarily represents an element to a user. Centralises the
+ * label-lookup logic so both LLM-facing reads (label-text echoes in tool results,
+ * `query-elements` rendering) and writes (`ApplyLabelEditOperation` from `create-nodes` /
+ * `modify-nodes`) share one override point.
+ *
+ * Diagram-scope: bound per GLSP session via {@link DefaultMcpDiagramModule.bindLabelProvider}.
+ * Adopters with non-trivial label structures (nested headers, compartments) override the
+ * {@link DefaultMcpLabelProvider} once instead of per-handler.
+ *
+ * @experimental
+ */
+export interface McpLabelProvider {
+    /**
+     * The {@link GLabel} primarily representing this element to a user. Returns `undefined`
+     * when the element has no label.
+     */
+    getLabel(element: GModelElement): GLabel | undefined;
+}
+
+/**
+ * Default {@link McpLabelProvider}: returns the first direct {@link GLabel} child. Adopters
+ * whose elements wrap labels in intermediary container nodes (headers, compartments) subclass
+ * and override {@link getLabel}.
+ */
+@injectable()
+export class DefaultMcpLabelProvider implements McpLabelProvider {
+    getLabel(element: GModelElement): GLabel | undefined {
+        return element.children.find((child): child is GLabel => child instanceof GLabel);
+    }
+}

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

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

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

@@ -0,0 +1,90 @@
+/********************************************************************************
+ * 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 { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
+import { injectable } from 'inversify';
+
+export const McpLogLevelRegistry = Symbol('McpLogLevelRegistry');
+
+/**
+ * Per-MCP-session minimum-severity threshold for `notifications/message`. Updated by the
+ * server's `logging/setLevel` request handler (registered in {@link McpServerLauncher} on
+ * session-init); read by {@link McpLogger} to gate message delivery.
+ *
+ * Bound as a server-scope singleton: one registry shared across MCP sessions, keyed by
+ * session id. On session-close, the entry is cleared so a recycled session id does not
+ * inherit a stale threshold.
+ */
+export interface McpLogLevelRegistry {
+    /** Update the minimum severity for a session. Called by the SDK setLevel request handler. */
+    setLevel(sessionId: string, level: LoggingLevel): void;
+    /** Resolve the active threshold for a session, falling back to the default for unknown ids. */
+    getLevel(sessionId: string | undefined): LoggingLevel;
+    /** Drop the per-session entry on session-close. */
+    clear(sessionId: string): void;
+}
+
+/**
+ * RFC 5424 severity numbering, mirroring the MCP `LoggingLevel` enum. Lower number = more
+ * severe; the threshold compares numerically.
+ */
+const SEVERITY: Record<LoggingLevel, number> = {
+    emergency: 0,
+    alert: 1,
+    critical: 2,
+    error: 3,
+    warning: 4,
+    notice: 5,
+    info: 6,
+    debug: 7
+};
+
+/**
+ * Returns `true` iff a message of severity {@link level} should be delivered given the
+ * session's current {@link threshold}. A `setLevel('warning')` call drops `notice`, `info`,
+ * and `debug`; `setLevel('debug')` keeps everything (the default).
+ */
+export function passesLogThreshold(level: LoggingLevel, threshold: LoggingLevel): boolean {
+    return SEVERITY[level] <= SEVERITY[threshold];
+}
+
+@injectable()
+export class DefaultMcpLogLevelRegistry implements McpLogLevelRegistry {
+    /**
+     * Default threshold used when the client has not sent `logging/setLevel`. `'debug'` is the
+     * MCP-spec-permitted "send everything" mode (the spec lets the server decide if no
+     * setLevel was received). Set wide so adopters who never wire setLevel see the same
+     * verbose behavior the server had before this registry existed.
+     */
+    static readonly DEFAULT_LEVEL: LoggingLevel = 'debug';
+
+    protected readonly levels = new Map<string, LoggingLevel>();
+
+    setLevel(sessionId: string, level: LoggingLevel): void {
+        this.levels.set(sessionId, level);
+    }
+
+    getLevel(sessionId: string | undefined): LoggingLevel {
+        if (sessionId === undefined) {
+            return DefaultMcpLogLevelRegistry.DEFAULT_LEVEL;
+        }
+        return this.levels.get(sessionId) ?? DefaultMcpLogLevelRegistry.DEFAULT_LEVEL;
+    }
+
+    clear(sessionId: string): void {
+        this.levels.delete(sessionId);
+    }
+}

package/src/server/mcp-logger.spec.ts

@@ -0,0 +1,227 @@
+/********************************************************************************
+ * 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, NullLogger } from '@eclipse-glsp/server';
+import { ServerNotification } from '@modelcontextprotocol/sdk/types.js';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import { DefaultMcpLogLevelRegistry, McpLogLevelRegistry } from './mcp-log-level-registry';
+import { McpLogger } from './mcp-logger';
+import { McpRequestExtra, mcpRequestContext } from './mcp-request-context';
+
+interface RecordedLog {
+    level: string;
+    message: string;
+}
+
+class RecordingLogger extends NullLogger {
+    readonly entries: RecordedLog[] = [];
+    override info(message: string): void {
+        this.entries.push({ level: 'info', message });
+    }
+    override warn(message: string): void {
+        this.entries.push({ level: 'warn', message });
+    }
+    override error(message: string): void {
+        this.entries.push({ level: 'error', message });
+    }
+    override debug(message: string): void {
+        this.entries.push({ level: 'debug', message });
+    }
+}
+
+function buildLogger(): { logger: McpLogger; glspLogger: RecordingLogger; levelRegistry: DefaultMcpLogLevelRegistry } {
+    const container = new Container();
+    const glspLogger = new RecordingLogger();
+    const levelRegistry = new DefaultMcpLogLevelRegistry();
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(glspLogger);
+            bind(McpLogLevelRegistry).toConstantValue(levelRegistry);
+            bind(McpLogger).toSelf().inSingletonScope();
+        })
+    );
+    return { logger: container.get(McpLogger), glspLogger, levelRegistry };
+}
+
+/**
+ * Build a stub `RequestHandlerExtra` with a recording `sendNotification`. Only `sendNotification`
+ * is exercised by `McpLogger`; the remaining fields are never read here, so we cast rather
+ * than fabricate the full SDK shape.
+ */
+function buildExtra(sessionId?: string): { extra: McpRequestExtra; sent: ServerNotification[] } {
+    const sent: ServerNotification[] = [];
+    const extra = {
+        sessionId,
+        sendNotification: async (n: ServerNotification) => {
+            sent.push(n);
+        }
+    } as unknown as McpRequestExtra;
+    return { extra, sent };
+}
+
+describe('McpLogger', () => {
+    describe('outside a request context (no MCP client to deliver to)', () => {
+        it('routes info/warn/error/debug to the GLSP Logger only', () => {
+            const { logger, glspLogger } = buildLogger();
+
+            logger.info('hello');
+            logger.warn('careful');
+            logger.error('boom');
+            logger.debug('trace');
+
+            expect(glspLogger.entries).to.deep.equal([
+                { level: 'info', message: 'hello' },
+                { level: 'warn', message: 'careful' },
+                { level: 'error', message: 'boom' },
+                { level: 'debug', message: 'trace' }
+            ]);
+        });
+    });
+
+    describe('inside an mcpRequestContext.run frame', () => {
+        it('emits notifications/message to the bound MCP client AND the GLSP Logger', async () => {
+            const { logger, glspLogger } = buildLogger();
+            const { extra, sent } = buildExtra();
+
+            await mcpRequestContext.run(extra, async () => {
+                logger.info('one');
+                logger.warn('two');
+                logger.error('three');
+                logger.debug('four');
+                // Allow the fire-and-forget `.catch` chain in McpLogger.notify to settle.
+                await new Promise(resolve => setImmediate(resolve));
+            });
+
+            expect(glspLogger.entries.map(e => e.message)).to.deep.equal(['one', 'two', 'three', 'four']);
+            expect(
+                sent.map(n => ({
+                    method: n.method,
+                    level: (n.params as { level: string }).level,
+                    data: (n.params as { data: string }).data
+                }))
+            ).to.deep.equal([
+                { method: 'notifications/message', level: 'info', data: 'one' },
+                { method: 'notifications/message', level: 'warning', data: 'two' }, // GLSP warn → MCP warning
+                { method: 'notifications/message', level: 'error', data: 'three' },
+                { method: 'notifications/message', level: 'debug', data: 'four' }
+            ]);
+        });
+
+        it('swallows transport failures so a broken MCP send never breaks the producing tool', async () => {
+            const { logger, glspLogger } = buildLogger();
+            const failingExtra = {
+                sendNotification: async () => {
+                    throw new Error('transport closed');
+                }
+            } as unknown as McpRequestExtra;
+
+            await mcpRequestContext.run(failingExtra, async () => {
+                expect(() => logger.error('still works')).to.not.throw();
+                await new Promise(resolve => setImmediate(resolve));
+            });
+
+            // Server-side log still fired.
+            expect(glspLogger.entries).to.deep.equal([{ level: 'error', message: 'still works' }]);
+        });
+    });
+
+    describe('concurrent request contexts', () => {
+        it('keeps each request frame isolated via AsyncLocalStorage', async () => {
+            const { logger } = buildLogger();
+            const { extra: extraA, sent: sentA } = buildExtra();
+            const { extra: extraB, sent: sentB } = buildExtra();
+
+            await Promise.all([
+                mcpRequestContext.run(extraA, async () => {
+                    logger.info('A');
+                    await new Promise(resolve => setImmediate(resolve));
+                    logger.info('A-after-yield');
+                }),
+                mcpRequestContext.run(extraB, async () => {
+                    logger.info('B');
+                    await new Promise(resolve => setImmediate(resolve));
+                    logger.info('B-after-yield');
+                })
+            ]);
+
+            expect(sentA.map(n => (n.params as { data: string }).data)).to.deep.equal(['A', 'A-after-yield']);
+            expect(sentB.map(n => (n.params as { data: string }).data)).to.deep.equal(['B', 'B-after-yield']);
+        });
+    });
+
+    describe('logging/setLevel threshold gate (G4)', () => {
+        it('drops messages below the per-session threshold; the GLSP-side log still fires', async () => {
+            const { logger, glspLogger, levelRegistry } = buildLogger();
+            const { extra, sent } = buildExtra('session-X');
+            // Client opted down to "warning" — info and debug must be dropped on the MCP side.
+            levelRegistry.setLevel('session-X', 'warning');
+
+            await mcpRequestContext.run(extra, async () => {
+                logger.info('chatty');
+                logger.debug('verbose');
+                logger.warn('important');
+                logger.error('critical');
+                await new Promise(resolve => setImmediate(resolve));
+            });
+
+            // GLSP-side log path is independent of the MCP threshold — keeps adopter logs intact.
+            expect(glspLogger.entries.map(entry => entry.message)).to.deep.equal(['chatty', 'verbose', 'important', 'critical']);
+            // MCP side: only warn + error survive.
+            expect(sent.map(n => (n.params as { level: string }).level)).to.deep.equal(['warning', 'error']);
+        });
+
+        it('isolates thresholds across sessions (different setLevel per session id)', async () => {
+            const { logger, levelRegistry } = buildLogger();
+            const { extra: extraA, sent: sentA } = buildExtra('session-A');
+            const { extra: extraB, sent: sentB } = buildExtra('session-B');
+            levelRegistry.setLevel('session-A', 'error');
+            levelRegistry.setLevel('session-B', 'debug');
+
+            await Promise.all([
+                mcpRequestContext.run(extraA, async () => {
+                    logger.info('A-info');
+                    logger.error('A-error');
+                    await new Promise(resolve => setImmediate(resolve));
+                }),
+                mcpRequestContext.run(extraB, async () => {
+                    logger.info('B-info');
+                    logger.error('B-error');
+                    await new Promise(resolve => setImmediate(resolve));
+                })
+            ]);
+
+            expect(sentA.map(n => (n.params as { data: string }).data)).to.deep.equal(['A-error']);
+            expect(sentB.map(n => (n.params as { data: string }).data).sort()).to.deep.equal(['B-error', 'B-info']);
+        });
+
+        it('default threshold (no setLevel sent) lets every level through (preserves prior behavior)', async () => {
+            const { logger } = buildLogger();
+            const { extra, sent } = buildExtra('session-default');
+            // No setLevel call → default threshold = 'debug' → everything emitted.
+
+            await mcpRequestContext.run(extra, async () => {
+                logger.debug('d');
+                logger.info('i');
+                logger.warn('w');
+                logger.error('e');
+                await new Promise(resolve => setImmediate(resolve));
+            });
+
+            expect(sent.map(n => (n.params as { level: string }).level)).to.deep.equal(['debug', 'info', 'warning', 'error']);
+        });
+    });
+});

package/src/server/mcp-logger.ts

@@ -0,0 +1,91 @@
+/********************************************************************************
+ * 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 type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
+import { inject, injectable } from 'inversify';
+import { McpLogLevelRegistry, passesLogThreshold } from './mcp-log-level-registry';
+import { mcpRequestContext } from './mcp-request-context';
+
+/**
+ * Logger that writes to BOTH the GLSP-side server log and the connected MCP client.
+ *
+ * Mirrors the {@link Logger} shape so handlers can drop-in switch from `@inject(Logger)` to
+ * `@inject(McpLogger)`. The server-side route always fires; the MCP-side route fires only when
+ * a call is made from inside an MCP request callback (tracked via {@link mcpRequestContext}).
+ *
+ * We deliberately do NOT auto-forward arbitrary GLSP `Logger.info` calls to MCP clients —
+ * that would leak unrelated server-wide log lines into every connected LLM. Adopters opt in
+ * per-handler by injecting `McpLogger` instead of `Logger`.
+ *
+ * Level mapping (GLSP → MCP, RFC 5424 names per the MCP spec):
+ *  - `info`  → `info`
+ *  - `warn`  → `warning`
+ *  - `error` → `error`
+ *  - `debug` → `debug`
+ *
+ * Shared across MCP clients on the same GLSP session; per-client routing is handled by the
+ * active `mcpRequestContext` frame, and the per-MCP-session `logging/setLevel` threshold is
+ * stored in {@link McpLogLevelRegistry}.
+ *
+ * @experimental
+ */
+@injectable()
+export class McpLogger {
+    @inject(Logger) protected glspLogger: Logger;
+
+    @inject(McpLogLevelRegistry) protected levelRegistry: McpLogLevelRegistry;
+
+    info(message: string, ...meta: unknown[]): void {
+        this.glspLogger.info(message, ...meta);
+        this.notify('info', message);
+    }
+
+    warn(message: string, ...meta: unknown[]): void {
+        this.glspLogger.warn(message, ...meta);
+        this.notify('warning', message);
+    }
+
+    error(message: string, ...meta: unknown[]): void {
+        this.glspLogger.error(message, ...meta);
+        this.notify('error', message);
+    }
+
+    debug(message: string, ...meta: unknown[]): void {
+        this.glspLogger.debug(message, ...meta);
+        this.notify('debug', message);
+    }
+
+    /**
+     * Send a `notifications/message` to the connected MCP client when invoked inside an active
+     * request context AND the message passes the session's `logging/setLevel` threshold.
+     * Outside a request context (init contributions, background timers) this is a no-op so the
+     * same logger can be used everywhere without orphan-notification leaks.
+     *
+     * Failures to deliver are swallowed — a broken transport must not break the producing tool.
+     */
+    protected notify(level: LoggingLevel, data: string): void {
+        const extra = mcpRequestContext.getStore();
+        if (!extra) {
+            return;
+        }
+        const threshold = this.levelRegistry.getLevel(extra.sessionId);
+        if (!passesLogThreshold(level, threshold)) {
+            return;
+        }
+        extra.sendNotification({ method: 'notifications/message', params: { level, data } }).catch(() => undefined);
+    }
+}

package/src/server/mcp-mime-types.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * 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 { ProposalString } from '@eclipse-glsp/protocol';
+
+/**
+ * MIME type for an MCP resource. Annotating a `mimeType` field with this type prompts the IDE
+ * to suggest the listed common values; any other string the MCP SDK accepts is also valid (the
+ * `(string & {})` part of `ProposalString` keeps the field free-form).
+ *
+ * Unlike `MarkersReason` / `EditMode` (closed sets of framework-defined enum values), MIME
+ * types are open and IANA-defined — the listed literals are common, not exhaustive. There's
+ * no companion const object: at the call site, adopters write the string literal directly
+ * (`readonly mimeType: McpMimeType = 'image/png';`).
+ */
+export type McpMimeType = ProposalString<
+    'text/plain' | 'text/markdown' | 'text/html' | 'application/json' | 'image/png' | 'image/jpeg' | 'image/svg+xml'
+>;

package/src/server/mcp-options.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * 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 { McpServerOptions as McpServerOptionsType } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+
+/**
+ * Holds the launcher-scoped MCP options. The launcher merges adopter-provided defaults
+ * (passed to the {@link AbstractMcpServerModule} constructor, bound as
+ * {@link McpServerDefaults}) with deployment-time overrides from the GLSP `initialize` request,
+ * then writes the merged result to `values`. Consumers `@inject(McpServerOptions)` and read
+ * `.values.<key>` directly.
+ *
+ * Bound as a singleton on the server container — the shared reference means server-scope
+ * singletons constructed before init still observe populated values once init runs.
+ *
+ * @experimental
+ */
+@injectable()
+export class McpServerOptions {
+    values: McpServerOptionsType = {};
+}
+
+/**
+ * DI binding identifier for adopter-provided default options. Supplied via the
+ * {@link AbstractMcpServerModule} constructor and merged with init-time options by
+ * `McpServerLauncher.initializeServer` — init-time wins per field.
+ */
+export const McpServerDefaults = Symbol('McpServerDefaults');
+export type McpServerDefaults = McpServerOptionsType;