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

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@eclipse-glsp/server-mcp",
+  "version": "2.7.0-next.10+bed0bb0",
+  "description": "Extension of the GLSP Node Server for the Model Context Protocol",
+  "keywords": [
+    "eclipse",
+    "graphics",
+    "diagram",
+    "modeling",
+    "visualization",
+    "glsp",
+    "diagram editor",
+    "mcp"
+  ],
+  "homepage": "https://www.eclipse.org/glsp/",
+  "bugs": "https://github.com/eclipse-glsp/glsp/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eclipse-glsp/glsp-server-node.git"
+  },
+  "license": "(EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0)",
+  "author": {
+    "name": "Eclipse GLSP"
+  },
+  "contributors": [
+    {
+      "name": "Eclipse GLSP Project",
+      "email": "glsp-dev@eclipse.org",
+      "url": "https://projects.eclipse.org/projects/ecd.glsp"
+    }
+  ],
+  "main": "lib/index",
+  "types": "lib/index",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf lib *.tsbuildinfo coverage .nyc_output",
+    "generate:index": "glsp generateIndex src -f -s",
+    "lint": "eslint --ext .ts,.tsx ./src",
+    "test": "mocha --config ../../.mocharc \"./src/**/*.spec.?(ts|tsx)\"",
+    "test:ci": "yarn test --reporter mocha-ctrf-json-reporter",
+    "test:coverage": "nyc yarn test",
+    "watch": "tsc -w"
+  },
+  "dependencies": {
+    "@eclipse-glsp/server": "2.7.0-next.10+bed0bb0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "express": "^5.2.1"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6"
+  },
+  "peerDependencies": {
+    "inversify": "^6.1.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "bed0bb089fb49e7a5cf5be5dfe02d4116dae944f"
+}

package/src/index.ts

@@ -0,0 +1,65 @@
+/********************************************************************************
+ * Copyright (c) 2025-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/mcp-diagram-module';
+export * from './modules/mcp-server-module';
+export * from './prompts/handlers/describe-diagram-mcp-prompt-handler';
+export * from './prompts/handlers/suggest-improvements-mcp-prompt-handler';
+export * from './resources/handlers/diagram-png-mcp-resource-handler';
+export * from './resources/handlers/diagram-svg-mcp-resource-handler';
+export * from './resources/services/element-types-provider';
+export * from './resources/services/mcp-model-serializer';
+export * from './server/glsp-mcp-server';
+export * from './server/lru-event-store';
+export * from './server/mcp-diagram-handler-dispatcher';
+export * from './server/mcp-diagram-prompt-handler-registry';
+export * from './server/mcp-diagram-resource-handler-registry';
+export * from './server/mcp-diagram-tool-handler-registry';
+export * from './server/mcp-handler-shared';
+export * from './server/mcp-http-transport';
+export * from './server/mcp-id-alias-service';
+export * from './server/mcp-input-schemas';
+export * from './server/mcp-label-provider';
+export * from './server/mcp-log-level-registry';
+export * from './server/mcp-logger';
+export * from './server/mcp-mime-types';
+export * from './server/mcp-options';
+export * from './server/mcp-progress-reporter';
+export * from './server/mcp-prompt-handler';
+export * from './server/mcp-request-context';
+export * from './server/mcp-resource-handler';
+export * from './server/mcp-server-launcher';
+export * from './server/mcp-session';
+export * from './server/mcp-tool-handler';
+export * from './tools/handlers/count-elements-mcp-tool-handler';
+export * from './tools/handlers/create-edges-mcp-tool-handler';
+export * from './tools/handlers/create-nodes-mcp-tool-handler';
+export * from './tools/handlers/delete-elements-mcp-tool-handler';
+export * from './tools/handlers/diagram-model-mcp-tool-handler';
+export * from './tools/handlers/element-types-mcp-tool-handler';
+export * from './tools/handlers/get-selection-mcp-tool-handler';
+export * from './tools/handlers/layout-mcp-tool-handler';
+export * from './tools/handlers/modify-edges-mcp-tool-handler';
+export * from './tools/handlers/modify-nodes-mcp-tool-handler';
+export * from './tools/handlers/query-elements-mcp-tool-handler';
+export * from './tools/handlers/redo-mcp-tool-handler';
+export * from './tools/handlers/save-model-mcp-tool-handler';
+export * from './tools/handlers/session-info-mcp-tool-handler';
+export * from './tools/handlers/set-selection-mcp-tool-handler';
+export * from './tools/handlers/set-view-mcp-tool-handler';
+export * from './tools/handlers/undo-mcp-tool-handler';
+export * from './tools/handlers/validate-diagram-mcp-tool-handler';
+export * from './util/markdown-util';
+export * from './util/mcp-util';

package/src/modules/mcp-diagram-module.ts

@@ -0,0 +1,247 @@
+/********************************************************************************
+ * 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 { applyBindingTarget, BindingTarget, ClientSessionInitializer, GLSPModule, InstanceMultiBinding } from '@eclipse-glsp/server';
+import { interfaces } from 'inversify';
+import { DiagramPngMcpResourceHandler } from '../resources/handlers/diagram-png-mcp-resource-handler';
+import { DiagramSvgMcpResourceHandler } from '../resources/handlers/diagram-svg-mcp-resource-handler';
+import { DefaultElementTypesProvider, ElementTypesProvider } from '../resources/services/element-types-provider';
+import { MarkdownMcpModelSerializer, McpModelSerializer } from '../resources/services/mcp-model-serializer';
+import { CountElementsMcpToolHandler } from '../tools/handlers/count-elements-mcp-tool-handler';
+import { CreateEdgesMcpToolHandler } from '../tools/handlers/create-edges-mcp-tool-handler';
+import { CreateNodesMcpToolHandler } from '../tools/handlers/create-nodes-mcp-tool-handler';
+import { DeleteElementsMcpToolHandler } from '../tools/handlers/delete-elements-mcp-tool-handler';
+import { DiagramModelMcpToolHandler } from '../tools/handlers/diagram-model-mcp-tool-handler';
+import { GetSelectionMcpToolHandler } from '../tools/handlers/get-selection-mcp-tool-handler';
+import { LayoutMcpToolHandler } from '../tools/handlers/layout-mcp-tool-handler';
+import { ModifyEdgesMcpToolHandler } from '../tools/handlers/modify-edges-mcp-tool-handler';
+import { ModifyNodesMcpToolHandler } from '../tools/handlers/modify-nodes-mcp-tool-handler';
+import { QueryElementsMcpToolHandler } from '../tools/handlers/query-elements-mcp-tool-handler';
+import { RedoMcpToolHandler } from '../tools/handlers/redo-mcp-tool-handler';
+import { SaveModelMcpToolHandler } from '../tools/handlers/save-model-mcp-tool-handler';
+import { SetSelectionMcpToolHandler } from '../tools/handlers/set-selection-mcp-tool-handler';
+import { SetViewMcpToolHandler } from '../tools/handlers/set-view-mcp-tool-handler';
+import { UndoMcpToolHandler } from '../tools/handlers/undo-mcp-tool-handler';
+import { ValidateDiagramMcpToolHandler } from '../tools/handlers/validate-diagram-mcp-tool-handler';
+import {
+    McpDiagramPromptHandlerFactory,
+    McpDiagramPromptHandlerRegistry,
+    McpDiagramPromptHandlerRegistryInitializer
+} from '../server/mcp-diagram-prompt-handler-registry';
+import {
+    McpDiagramResourceHandlerFactory,
+    McpDiagramResourceHandlerRegistry,
+    McpDiagramResourceHandlerRegistryInitializer
+} from '../server/mcp-diagram-resource-handler-registry';
+import {
+    McpDiagramToolHandlerFactory,
+    McpDiagramToolHandlerRegistry,
+    McpDiagramToolHandlerRegistryInitializer
+} from '../server/mcp-diagram-tool-handler-registry';
+import { DefaultMcpIdAliasService, McpIdAliasService } from '../server/mcp-id-alias-service';
+import { McpDiagramScopedInput } from '../server/mcp-input-schemas';
+import { DefaultMcpLabelProvider, McpLabelProvider } from '../server/mcp-label-provider';
+import { AbstractMcpDiagramPromptHandler, McpDiagramPromptHandlerConstructor } from '../server/mcp-prompt-handler';
+import { AbstractMcpDiagramResourceHandler, McpDiagramResourceHandlerConstructor } from '../server/mcp-resource-handler';
+import { BaseMcpDiagramToolHandler, McpDiagramToolHandlerConstructor } from '../server/mcp-tool-handler';
+
+/**
+ * Per-GLSP-client-session DI module for the MCP server. Loaded inside `configureDiagramModule`
+ * so each `ClientSession.container` gets its own instance of session-scoped services.
+ *
+ * Binds the {@link McpIdAliasService}, the {@link McpModelSerializer}, the
+ * {@link ElementTypesProvider}, and the diagram-scope handler-constructor multi-bindings
+ * (`McpDiagram*HandlerConstructor`). Adopters subclass and override the `bind*` hooks to swap
+ * single-instance services and the `configure*` hooks to extend the multi-binding handler sets.
+ *
+ * @example
+ * ```ts
+ * class WorkflowMcpDiagramModule extends DefaultMcpDiagramModule {
+ *     // Single-instance binding: return the class.
+ *     protected override bindModelSerializer(): BindingTarget<McpModelSerializer> {
+ *         return WorkflowMcpModelSerializer;
+ *     }
+ *     // Multi-binding: extend or rebind the default set.
+ *     protected override configureToolHandlers(binding) {
+ *         super.configureToolHandlers(binding);
+ *         binding.add(WorkflowExtraTool);
+ *         binding.rebind(CreateNodesMcpToolHandler, WorkflowCreateNodesMcpToolHandler);
+ *     }
+ * }
+ * new WorkflowServerModule().configureDiagramModule(
+ *     new WorkflowDiagramModule(...),
+ *     elkLayoutModule,
+ *     new WorkflowMcpDiagramModule()
+ * );
+ * ```
+ */
+export abstract class AbstractMcpDiagramModule extends GLSPModule {
+    protected bind!: interfaces.Bind;
+    protected rebind!: interfaces.Rebind;
+
+    protected override configure(
+        bind: interfaces.Bind,
+        _unbind: interfaces.Unbind,
+        isBound: interfaces.IsBound,
+        rebind: interfaces.Rebind
+    ): void {
+        this.bind = bind;
+        this.rebind = rebind;
+        const context = { bind, isBound };
+        applyBindingTarget(context, McpIdAliasService, this.bindIdAliasService()).inSingletonScope();
+        applyBindingTarget(context, McpLabelProvider, this.bindLabelProvider()).inSingletonScope();
+        applyBindingTarget(context, McpModelSerializer, this.bindModelSerializer()).inSingletonScope();
+        applyBindingTarget(context, ElementTypesProvider, this.bindElementTypesProvider()).inSingletonScope();
+        this.configureMultiBinding(new InstanceMultiBinding<McpDiagramToolHandlerConstructor>(McpDiagramToolHandlerConstructor), binding =>
+            this.configureToolHandlers(binding as InstanceMultiBinding<McpDiagramToolHandlerConstructor>)
+        );
+        this.configureMultiBinding(
+            new InstanceMultiBinding<McpDiagramResourceHandlerConstructor>(McpDiagramResourceHandlerConstructor),
+            binding => this.configureResourceHandlers(binding as InstanceMultiBinding<McpDiagramResourceHandlerConstructor>)
+        );
+        this.configureMultiBinding(
+            new InstanceMultiBinding<McpDiagramPromptHandlerConstructor>(McpDiagramPromptHandlerConstructor),
+            binding => this.configurePromptHandlers(binding as InstanceMultiBinding<McpDiagramPromptHandlerConstructor>)
+        );
+        this.configureHandlerRegistries();
+    }
+
+    /**
+     * Bind the per-GLSP-session handler registries, factories, and {@link ClientSessionInitializer}s
+     * that populate the registries at session-open. Adopters typically don't override.
+     *
+     * Each kind (tool / resource / prompt) follows the same shape:
+     *  - `Registry` — singleton-per-session, holds instantiated handlers keyed by `name`.
+     *  - `Factory` — `dynamicValue` that calls `ctx.container.resolve(constructor)`, so the
+     *    handler's `@inject(...)` fields resolve against the live `ClientSession.container`.
+     *  - `RegistryInitializer` — at session-open, reads the constructor multi-binding (added by
+     *    adopter `configure*Handlers` overrides) and instantiates each via the factory.
+     *    Picked up by Inversify alongside core's own `ClientSessionInitializer`s
+     *    (`OperationHandlerRegistryInitializer` etc.).
+     */
+    protected configureHandlerRegistries(): void {
+        this.bind(McpDiagramToolHandlerRegistry).toSelf().inSingletonScope();
+        this.bind<McpDiagramToolHandlerFactory>(McpDiagramToolHandlerFactory).toDynamicValue(
+            ctx => (constructor: McpDiagramToolHandlerConstructor) =>
+                ctx.container.resolve<BaseMcpDiagramToolHandler<McpDiagramScopedInput>>(constructor)
+        );
+        this.bind(McpDiagramToolHandlerRegistryInitializer).toSelf().inSingletonScope();
+        this.bind(ClientSessionInitializer).toService(McpDiagramToolHandlerRegistryInitializer);
+
+        this.bind(McpDiagramResourceHandlerRegistry).toSelf().inSingletonScope();
+        this.bind<McpDiagramResourceHandlerFactory>(McpDiagramResourceHandlerFactory).toDynamicValue(
+            ctx => (constructor: McpDiagramResourceHandlerConstructor) =>
+                ctx.container.resolve<AbstractMcpDiagramResourceHandler<McpDiagramScopedInput>>(constructor)
+        );
+        this.bind(McpDiagramResourceHandlerRegistryInitializer).toSelf().inSingletonScope();
+        this.bind(ClientSessionInitializer).toService(McpDiagramResourceHandlerRegistryInitializer);
+
+        this.bind(McpDiagramPromptHandlerRegistry).toSelf().inSingletonScope();
+        this.bind<McpDiagramPromptHandlerFactory>(McpDiagramPromptHandlerFactory).toDynamicValue(
+            ctx => (constructor: McpDiagramPromptHandlerConstructor) =>
+                ctx.container.resolve<AbstractMcpDiagramPromptHandler<McpDiagramScopedInput>>(constructor)
+        );
+        this.bind(McpDiagramPromptHandlerRegistryInitializer).toSelf().inSingletonScope();
+        this.bind(ClientSessionInitializer).toService(McpDiagramPromptHandlerRegistryInitializer);
+    }
+
+    /**
+     * {@link McpIdAliasService} binding. Override to swap in a custom alias strategy. Bind the
+     * shipped `NullMcpIdAliasService` (passthrough) to expose raw GLSP ids on the wire — useful
+     * for diagnostic readability or when token cost isn't a concern.
+     */
+    protected bindIdAliasService(): BindingTarget<McpIdAliasService> {
+        return DefaultMcpIdAliasService;
+    }
+
+    /**
+     * {@link McpLabelProvider} binding. Override to teach MCP about adopter-specific label
+     * locations (e.g., labels nested in header components or compartments). One override here
+     * covers every read-side echo and every write-side label-edit operation.
+     */
+    protected bindLabelProvider(): BindingTarget<McpLabelProvider> {
+        return DefaultMcpLabelProvider;
+    }
+
+    /**
+     * {@link McpModelSerializer} binding. Override to swap in a diagram-type-specific serializer
+     * (e.g. one that emits JSON, or knows the adopter's element schema). Per-session scope means
+     * each diagram type provides its own serializer without a server-level rebind.
+     */
+    protected bindModelSerializer(): BindingTarget<McpModelSerializer> {
+        return MarkdownMcpModelSerializer;
+    }
+
+    /**
+     * {@link ElementTypesProvider} binding. Override to ship a constant-value list of creatable
+     * element types for the adopter's diagram type instead of the default impl that scrapes
+     * {@link OperationHandlerRegistry} (noisy for non-trivial diagrams).
+     */
+    protected bindElementTypesProvider(): BindingTarget<ElementTypesProvider> {
+        return DefaultElementTypesProvider;
+    }
+
+    /**
+     * Override to add or replace diagram-scope tool handlers. Adopters typically
+     * `super.configureToolHandlers(binding)` to keep the defaults, then `binding.add(MyTool)`
+     * for additions or `binding.rebind(StandardTool, MyTool)` for overrides.
+     */
+    protected configureToolHandlers(binding: InstanceMultiBinding<McpDiagramToolHandlerConstructor>): void {
+        binding.add(CreateNodesMcpToolHandler);
+        binding.add(CreateEdgesMcpToolHandler);
+        binding.add(DeleteElementsMcpToolHandler);
+        binding.add(SaveModelMcpToolHandler);
+        binding.add(ValidateDiagramMcpToolHandler);
+        binding.add(DiagramModelMcpToolHandler);
+        binding.add(QueryElementsMcpToolHandler);
+        binding.add(CountElementsMcpToolHandler);
+        binding.add(ModifyNodesMcpToolHandler);
+        binding.add(ModifyEdgesMcpToolHandler);
+        binding.add(UndoMcpToolHandler);
+        binding.add(RedoMcpToolHandler);
+        binding.add(GetSelectionMcpToolHandler);
+        binding.add(SetSelectionMcpToolHandler);
+        binding.add(SetViewMcpToolHandler);
+        // Auto-skips at session-open via `canRegister()` when no `LayoutEngine` is bound.
+        binding.add(LayoutMcpToolHandler);
+    }
+
+    /** See {@link configureToolHandlers}. */
+    protected configureResourceHandlers(binding: InstanceMultiBinding<McpDiagramResourceHandlerConstructor>): void {
+        binding.add(DiagramPngMcpResourceHandler);
+        binding.add(DiagramSvgMcpResourceHandler);
+    }
+
+    /**
+     * See {@link configureToolHandlers}. No diagram-scope prompts ship by default — the shipped
+     * `describe-diagram` and `suggest-improvements` prompts are diagram-type-agnostic and bound
+     * server-scope. Adopters add their own diagram-type-specific prompts here.
+     */
+    protected configurePromptHandlers(_binding: InstanceMultiBinding<McpDiagramPromptHandlerConstructor>): void {
+        // empty by default
+    }
+}
+
+/**
+ * Default {@link AbstractMcpDiagramModule} entry point. Adopters who don't need overrides
+ * use it directly: `new DefaultMcpDiagramModule()`. Adopters with customizations subclass
+ * `AbstractMcpDiagramModule` (or this class) and override the `bind*` / `configure*` hooks.
+ *
+ * @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 DefaultMcpDiagramModule extends AbstractMcpDiagramModule {}

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

@@ -0,0 +1,289 @@
+/********************************************************************************
+ * 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 { BindingContext } from '@eclipse-glsp/protocol/lib/di';
+import {
+    AbstractMultiBinding,
+    applyBindingTarget,
+    BindingTarget,
+    GLSPModule,
+    GLSPServerInitializer,
+    GLSPServerListener,
+    Logger
+} from '@eclipse-glsp/server';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { interfaces } from 'inversify';
+import { DescribeDiagramMcpPromptHandler } from '../prompts/handlers/describe-diagram-mcp-prompt-handler';
+import { SuggestImprovementsMcpPromptHandler } from '../prompts/handlers/suggest-improvements-mcp-prompt-handler';
+import { ElementTypesMcpToolHandler } from '../tools/handlers/element-types-mcp-tool-handler';
+import { SessionInfoMcpToolHandler } from '../tools/handlers/session-info-mcp-tool-handler';
+import { DefaultGLSPMcpServer, GLSPMcpServerFactory } from '../server/glsp-mcp-server';
+import { DefaultMcpDiagramHandlerDispatcher, McpDiagramHandlerDispatcher } from '../server/mcp-diagram-handler-dispatcher';
+import { DefaultMcpLogLevelRegistry, McpLogLevelRegistry } from '../server/mcp-log-level-registry';
+import { LruEventStore } from '../server/lru-event-store';
+import { McpHttpTransport } from '../server/mcp-http-transport';
+import { McpLogger } from '../server/mcp-logger';
+import { McpServerDefaults, McpServerOptions } from '../server/mcp-options';
+import { McpProgressReporter } from '../server/mcp-progress-reporter';
+import { McpPromptHandler } from '../server/mcp-prompt-handler';
+import { McpResourceHandler } from '../server/mcp-resource-handler';
+import { McpServerLauncher } from '../server/mcp-server-launcher';
+import { McpToolHandler } from '../server/mcp-tool-handler';
+
+/**
+ * GLSP-generic default agent persona — adopters typically pass a product-specific persona to
+ * the {@link DefaultMcpServerModule} constructor (e.g. workflow-server might say "You are the
+ * Workflow Modeling Agent...").
+ *
+ * **Spec note.** This is wired to the MCP `instructions` field, which the spec describes as
+ * "concise instructions". This persona is intentionally verbose (~700 chars of behavior rules)
+ * — within the spec's "free-form server-supplied instructions" allowance and adopter-overridable
+ * via `mcpDefaults.agentPersona`. Don't trim on autopilot if a "concise" interpretation drifts
+ * back: the verbose form materially improves LLM tool-use compliance for graphical modelling.
+ */
+const DEFAULT_AGENT_PERSONA = `
+You are the GLSP Modeling Agent. Your primary goal is to assist in the creation and modification of graphical models using the
+GLSP MCP server. You have to adhere to the following principles:
+- MCP-Interaction: Any modeling related activity has to occur using the MCP server.
+- Real Data: The diagram model is the ground truth regarding the existing graphical model. Always query it before modifying the diagram.
+- Real Creation: Consult the available element types before creating elements.
+- Visual Proof: An image of the graphical model can be created, if you deem it useful for calculating or verifying layout decisions.
+- Precision: All IDs and types must be exact.
+- Visualization: When creating nodes, suggest sensible default positions and avoid visual overlapping.
+- Careful: Under no circumstances save the model without explicit instruction. If you deem it sensible, you may ask the user for permission.
+  The same goes for Undo/Redo operations.
+- Layouting: If available, make use of automatic layouting when not given explicit custom layouting requirements.
+- Human-friendly references: When mentioning an element in user-visible prose, prefer its label, then its element type
+  (the bare ids returned by the tools are internal aliases that mean nothing to the user). Append the alias in parentheses
+  so the user can correlate it with follow-up tools. Use the \`set-selection\` tool — or the \`set-view\` tool with
+  \`action: "center-on-elements"\` — to point the user at the elements you reference.
+`;
+
+/**
+ * Multi-binding helper for MCP handler classes. Singleton-scoped sibling of core's
+ * `MultiBinding<T>` — same `binding.add(...)` / `binding.rebind(old, new)` adopter shape, but
+ * core's plain `MultiBinding` binds in transient scope, while MCP handlers cache deferred
+ * resolvers (selection/PNG round-trips) and need singleton scope to keep their state.
+ */
+export class McpHandlerMultiBinding<T> extends AbstractMultiBinding<interfaces.Newable<T>> {
+    override applyBindings(context: BindingContext): void {
+        this.bindings.forEach(handlerClass => {
+            if (!context.isBound(handlerClass)) {
+                context.bind(handlerClass).toSelf().inSingletonScope();
+            }
+            context.bind(this.identifier).toService(handlerClass);
+        });
+    }
+}
+
+/**
+ * Server-scope DI module for the MCP server. Adopters subclass {@link DefaultMcpServerModule}
+ * and override the `bind*` hooks to swap single-instance services or the `configure*` hooks to
+ * add/replace handlers in the multi-bindings. Mirrors the `DiagramModule` pattern from core
+ * (`bindGModelSerializer()`, `configureActionHandlers(binding)`, etc.).
+ *
+ * Adopter-provided default option values flow through the constructor — pass a
+ * `Partial<McpServerOptions>` to override individual fields. The launcher then merges these
+ * defaults with init-time options from the GLSP `initialize` request (init-time wins per field).
+ *
+ * @example
+ * ```ts
+ * // Drop-in: GLSP defaults.
+ * launcher.configure(serverModule, new DefaultMcpServerModule());
+ *
+ * // Drop-in with a product-specific override.
+ * launcher.configure(serverModule, new DefaultMcpServerModule({ dataMode: 'resources' }));
+ *
+ * // Subclass when handler customization is needed.
+ * class WorkflowMcpServerModule extends DefaultMcpServerModule {
+ *     constructor() { super({ agentPersona: WORKFLOW_PERSONA }); }
+ *     protected override configureToolHandlers(binding) {
+ *         super.configureToolHandlers(binding);
+ *         binding.add(WorkflowSpecificTool);
+ *     }
+ * }
+ * ```
+ */
+export abstract class AbstractMcpServerModule extends GLSPModule {
+    protected bind!: interfaces.Bind;
+    protected rebind!: interfaces.Rebind;
+
+    constructor(protected readonly defaultOptions: McpServerDefaults = {}) {
+        super();
+    }
+
+    protected override configure(
+        bind: interfaces.Bind,
+        _unbind: interfaces.Unbind,
+        isBound: interfaces.IsBound,
+        rebind: interfaces.Rebind
+    ): void {
+        this.bind = bind;
+        this.rebind = rebind;
+        const context = { bind, isBound };
+        applyBindingTarget(context, McpServerLauncher, this.bindMcpServerLauncher()).inSingletonScope();
+        // The launcher is bound under two additional service identifiers so core's existing
+        // multi-bindings pick it up alongside the rest of the server's contributions/listeners.
+        bind(GLSPServerInitializer).toService(McpServerLauncher);
+        bind(GLSPServerListener).toService(McpServerLauncher);
+        applyBindingTarget(context, McpHttpTransport, this.bindMcpHttpTransport()).inSingletonScope();
+        applyBindingTarget(context, McpDiagramHandlerDispatcher, this.bindMcpDiagramHandlerDispatcher()).inSingletonScope();
+        applyBindingTarget(context, McpServerOptions, this.bindMcpServerOptions()).inSingletonScope();
+        applyBindingTarget(context, McpServerDefaults, this.bindMcpServerDefaults());
+        applyBindingTarget(context, McpLogger, this.bindMcpLogger()).inSingletonScope();
+        applyBindingTarget(context, McpLogLevelRegistry, this.bindMcpLogLevelRegistry()).inSingletonScope();
+        applyBindingTarget(context, McpProgressReporter, this.bindMcpProgressReporter()).inSingletonScope();
+        applyBindingTarget(context, GLSPMcpServerFactory, this.bindGLSPMcpServerFactory());
+        this.configureMultiBinding(new McpHandlerMultiBinding<McpToolHandler>(McpToolHandler), binding =>
+            this.configureToolHandlers(binding as McpHandlerMultiBinding<McpToolHandler>)
+        );
+        this.configureMultiBinding(new McpHandlerMultiBinding<McpResourceHandler>(McpResourceHandler), binding =>
+            this.configureResourceHandlers(binding as McpHandlerMultiBinding<McpResourceHandler>)
+        );
+        this.configureMultiBinding(new McpHandlerMultiBinding<McpPromptHandler>(McpPromptHandler), binding =>
+            this.configurePromptHandlers(binding as McpHandlerMultiBinding<McpPromptHandler>)
+        );
+    }
+
+    /**
+     * {@link McpServerLauncher} binding. Bound as a singleton AND aliased to
+     * `GLSPServerInitializer` + `GLSPServerListener` (the launcher implements both).
+     * Override to swap in a custom launcher impl.
+     */
+    protected bindMcpServerLauncher(): BindingTarget<McpServerLauncher> {
+        return McpServerLauncher;
+    }
+
+    /** {@link McpHttpTransport} binding. Override to swap to a different transport implementation. */
+    protected bindMcpHttpTransport(): BindingTarget<McpHttpTransport> {
+        return McpHttpTransport;
+    }
+
+    /**
+     * {@link McpDiagramHandlerDispatcher} binding. Owns diagram-scope handler discovery,
+     * SDK registration, and per-call dispatch routing. Override (or `rebind` to a subclass)
+     * to customize registration without subclassing the launcher itself.
+     */
+    protected bindMcpDiagramHandlerDispatcher(): BindingTarget<McpDiagramHandlerDispatcher> {
+        return DefaultMcpDiagramHandlerDispatcher;
+    }
+
+    /** {@link McpServerOptions} holder binding. Mutated at init by the launcher. */
+    protected bindMcpServerOptions(): BindingTarget<McpServerOptions> {
+        return McpServerOptions;
+    }
+
+    /**
+     * {@link McpServerDefaults} binding — adopter-supplied default option values flow through
+     * the constructor and land here as a constant. The launcher merges these defaults with
+     * init-time options at server init (init-time wins per field).
+     */
+    protected bindMcpServerDefaults(): BindingTarget<McpServerDefaults> {
+        return { constantValue: this.defaultOptions };
+    }
+
+    /**
+     * {@link McpLogger} binding. Bound on the server container; per-session containers inherit
+     * it, so handlers at any scope can inject it; routes through the active MCP request via
+     * {@link mcpRequestContext}.
+     */
+    protected bindMcpLogger(): BindingTarget<McpLogger> {
+        return McpLogger;
+    }
+
+    /** {@link McpProgressReporter} binding. Same scope/lifecycle story as {@link bindMcpLogger}. */
+    protected bindMcpProgressReporter(): BindingTarget<McpProgressReporter> {
+        return McpProgressReporter;
+    }
+
+    /**
+     * {@link McpLogLevelRegistry} binding — holds per-MCP-session `logging/setLevel` thresholds
+     * read by {@link McpLogger} when filtering `notifications/message`.
+     */
+    protected bindMcpLogLevelRegistry(): BindingTarget<McpLogLevelRegistry> {
+        return DefaultMcpLogLevelRegistry;
+    }
+
+    /**
+     * {@link GLSPMcpServerFactory} binding — produces a fresh {@link DefaultGLSPMcpServer} per
+     * MCP-session-init call. Override to wrap the SDK `McpServer` differently (e.g. add custom
+     * middleware, swap the Proxy strategy).
+     */
+    protected bindGLSPMcpServerFactory(): BindingTarget<GLSPMcpServerFactory> {
+        return {
+            dynamicValue: ctx => {
+                const logger = ctx.container.get<Logger>(Logger);
+                return (mcpServer: McpServer, options: McpServerOptionsType): DefaultGLSPMcpServer =>
+                    new DefaultGLSPMcpServer(mcpServer, options, logger);
+            }
+        };
+    }
+
+    /**
+     * Override to add or replace tool handlers. Adopters typically `super.configureToolHandlers(binding)`
+     * to keep the defaults, then `binding.add(MyTool)` for additions or
+     * `binding.rebind(StandardTool, MyTool)` for overrides.
+     */
+    protected configureToolHandlers(binding: McpHandlerMultiBinding<McpToolHandler>): void {
+        binding.add(SessionInfoMcpToolHandler);
+        binding.add(ElementTypesMcpToolHandler);
+    }
+
+    /** See {@link configureToolHandlers}. No server-scope resources ship by default. */
+    protected configureResourceHandlers(_binding: McpHandlerMultiBinding<McpResourceHandler>): void {
+        // empty by default
+    }
+
+    /**
+     * See {@link configureToolHandlers}. Server-scope by default because the shipped prompts
+     * (`describe-diagram`, `suggest-improvements`) are diagram-type-agnostic and resolve their
+     * target session at invocation time — diagram-scope adopters add prompts via
+     * {@link DefaultMcpDiagramModule.configurePromptHandlers}.
+     */
+    protected configurePromptHandlers(binding: McpHandlerMultiBinding<McpPromptHandler>): void {
+        binding.add(DescribeDiagramMcpPromptHandler);
+        binding.add(SuggestImprovementsMcpPromptHandler);
+    }
+}
+
+/**
+ * Default {@link AbstractMcpServerModule} entry point. Ships GLSP-default option values (see
+ * {@link DEFAULT_OPTIONS}) on top of the abstract module's hook defaults. 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 DefaultMcpServerModule extends AbstractMcpServerModule {
+    static readonly DEFAULT_OPTIONS: McpServerDefaults = {
+        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.
+        dataMode: 'tools',
+        agentPersona: DEFAULT_AGENT_PERSONA,
+        // 10K events per session is generous for typical workloads (a few MB) and large enough
+        // that disconnects within seconds recover via `Last-Event-ID` resumability.
+        eventStoreLimit: LruEventStore.DEFAULT_LIMIT
+    };
+
+    constructor(overrides: McpServerDefaults = {}) {
+        super({ ...DefaultMcpServerModule.DEFAULT_OPTIONS, ...overrides });
+    }
+}