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

package/src/tools/handlers/create-nodes-mcp-tool-handler.spec.ts

@@ -0,0 +1,197 @@
+/********************************************************************************
+ * 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 {
+    Action,
+    ActionDispatcher,
+    ApplyLabelEditOperation,
+    ClientId,
+    CreateNodeOperation,
+    GLabel,
+    GModelElement,
+    Logger,
+    ModelState,
+    NullLogger
+} from '@eclipse-glsp/server';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import { McpIdAliasService, McpLabelProvider, McpToolResult } from '../../server';
+import { CreateNodesInput, CreateNodesMcpToolHandler } from './create-nodes-mcp-tool-handler';
+
+interface CreatedElementsStructured {
+    createdNodes: { id: string; elementTypeId: string; label?: string }[];
+    errors: string[];
+    warnings: string[];
+}
+
+function makeElement(id: string, type: string, children: GModelElement[] = []): GModelElement {
+    return { id, type, children } as unknown as GModelElement;
+}
+
+/** Mutable model that drops in new elements as CreateNodeOperations are dispatched. */
+class FakeModelState {
+    public elements = new Map<string, GModelElement>();
+    constructor(initial: GModelElement[]) {
+        initial.forEach(el => this.elements.set(el.id, el));
+    }
+    addElement(el: GModelElement): void {
+        this.elements.set(el.id, el);
+    }
+    get index(): ModelState['index'] {
+        return {
+            allIds: () => [...this.elements.keys()],
+            get: (id: string) => this.elements.get(id),
+            find: (id: string) => this.elements.get(id)
+        } as unknown as ModelState['index'];
+    }
+    get isReadonly(): boolean {
+        return false;
+    }
+}
+
+/** Dispatcher that materializes a new element per `CreateNodeOperation` and records the action. */
+class CreatingDispatcher {
+    public dispatched: Action[] = [];
+    private idCounter = 0;
+    constructor(
+        private readonly model: FakeModelState,
+        private readonly labeled: Set<string>
+    ) {}
+
+    async dispatch(action: Action): Promise<void> {
+        this.dispatched.push(action);
+        if (CreateNodeOperation.is(action)) {
+            const id = `${action.elementTypeId}#${++this.idCounter}`;
+            const children: GModelElement[] = this.labeled.has(action.elementTypeId)
+                ? [Object.assign(new GLabel(), { id: `${id}_label`, type: 'label', children: [] })]
+                : [];
+            this.model.addElement(makeElement(id, action.elementTypeId, children));
+        }
+    }
+}
+
+interface BuildArgs {
+    /** Element types whose newly created instance includes a child GLabel. */
+    labeled?: string[];
+    /** Element types for which CreateNodeOperation should produce no new element (silent failure simulation). */
+    failed?: string[];
+}
+
+function buildHandler({ labeled = [], failed = [] }: BuildArgs = {}): {
+    handler: CreateNodesMcpToolHandler;
+    dispatcher: CreatingDispatcher;
+} {
+    const model = new FakeModelState([]);
+    const failedSet = new Set(failed);
+    const labeledSet = new Set(labeled);
+    const dispatcher = new (class extends CreatingDispatcher {
+        override async dispatch(action: Action): Promise<void> {
+            if (CreateNodeOperation.is(action) && failedSet.has(action.elementTypeId)) {
+                this.dispatched.push(action);
+                return;
+            }
+            return super.dispatch(action);
+        }
+    })(model, labeledSet);
+
+    const container = new Container();
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new NullLogger());
+            bind(ClientId).toConstantValue('test-session');
+            bind(ModelState).toConstantValue(model as unknown as ModelState);
+            bind(McpIdAliasService).toConstantValue({
+                lookup: (id: string) => id,
+                alias: (id: string) => id
+            } as McpIdAliasService);
+            bind(ActionDispatcher).toConstantValue(dispatcher as unknown as ActionDispatcher);
+            bind(McpLabelProvider).toConstantValue({
+                getLabel: (element: GModelElement) => element.children.find(c => c instanceof GLabel) as GLabel | undefined
+            } as McpLabelProvider);
+            bind(CreateNodesMcpToolHandler).toSelf();
+        })
+    );
+    return { handler: container.get(CreateNodesMcpToolHandler), dispatcher };
+}
+
+function callCreateResult(handler: CreateNodesMcpToolHandler, params: CreateNodesInput): Promise<McpToolResult> {
+    return (handler as unknown as { createResult: (p: CreateNodesInput) => Promise<McpToolResult> }).createResult(params);
+}
+
+describe('CreateNodesMcpToolHandler', () => {
+    it('dispatches one CreateNodeOperation per node and reports the new element ids', async () => {
+        const { handler, dispatcher } = buildHandler();
+
+        const result = await callCreateResult(handler, {
+            sessionId: 's',
+            nodes: [
+                { elementTypeId: 'task:manual', position: { x: 0, y: 0 } },
+                { elementTypeId: 'task:manual', position: { x: 100, y: 0 } }
+            ]
+        });
+
+        const structured = result.structuredContent as unknown as CreatedElementsStructured;
+        expect(structured.createdNodes).to.have.lengthOf(2);
+        expect(structured.createdNodes[0].id).to.equal('task:manual#1');
+        expect(structured.createdNodes[1].id).to.equal('task:manual#2');
+        expect(structured.errors).to.deep.equal([]);
+        expect(structured.warnings).to.deep.equal([]);
+        expect(dispatcher.dispatched.filter(CreateNodeOperation.is)).to.have.lengthOf(2);
+    });
+
+    it('dispatches ApplyLabelEditOperation when `text` is supplied and the new element has a label', async () => {
+        const { handler, dispatcher } = buildHandler({ labeled: ['task:manual'] });
+
+        await callCreateResult(handler, {
+            sessionId: 's',
+            nodes: [{ elementTypeId: 'task:manual', position: { x: 0, y: 0 }, text: 'Hello' }]
+        });
+
+        const edits = dispatcher.dispatched.filter(ApplyLabelEditOperation.is);
+        expect(edits).to.have.lengthOf(1);
+        expect(edits[0].text).to.equal('Hello');
+        expect(edits[0].labelId).to.equal('task:manual#1_label');
+    });
+
+    it('emits a warning (no ApplyLabelEditOperation) when `text` is supplied but the element type has no label', async () => {
+        const { handler, dispatcher } = buildHandler({ labeled: [] });
+
+        const result = await callCreateResult(handler, {
+            sessionId: 's',
+            nodes: [{ elementTypeId: 'decision', position: { x: 0, y: 0 }, text: 'Ignored' }]
+        });
+
+        const structured = result.structuredContent as unknown as CreatedElementsStructured;
+        expect(structured.warnings).to.have.lengthOf(1);
+        expect(structured.warnings[0]).to.match(/no editable label/i);
+        expect(dispatcher.dispatched.filter(ApplyLabelEditOperation.is)).to.have.lengthOf(0);
+    });
+
+    it('records an error and skips label-edit when the CreateNodeOperation produces no new element', async () => {
+        const { handler, dispatcher } = buildHandler({ failed: ['ghost'] });
+
+        const result = await callCreateResult(handler, {
+            sessionId: 's',
+            nodes: [{ elementTypeId: 'ghost', position: { x: 0, y: 0 }, text: 'Hello' }]
+        });
+
+        const structured = result.structuredContent as unknown as CreatedElementsStructured;
+        expect(structured.createdNodes).to.deep.equal([]);
+        expect(structured.errors).to.have.lengthOf(1);
+        expect(structured.errors[0]).to.include('ghost');
+        expect(dispatcher.dispatched.filter(ApplyLabelEditOperation.is)).to.have.lengthOf(0);
+    });
+});

package/src/tools/handlers/create-nodes-mcp-tool-handler.ts

@@ -0,0 +1,131 @@
+/********************************************************************************
+ * 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 { ApplyLabelEditOperation, CreateNodeOperation } from '@eclipse-glsp/server';
+import { injectable } from 'inversify';
+import * as z from 'zod/v4';
+import {
+    ElementIdentity,
+    ElementIdentitySchema,
+    McpDiagramScopedInputSchema,
+    McpToolResult,
+    OperationMcpDiagramToolHandler,
+    position
+} from '../../server';
+import { formatNoticeList } from '../../util';
+
+/** Single node-creation entry. Strict so an LLM-typoed field surfaces as a validation error instead of being silently dropped. */
+export const CreateNodeSpecSchema = z.strictObject({
+    elementTypeId: z
+        .string()
+        .describe('Element type ID (e.g., `task:manual`, `task:automated`). Use the `element-types` tool to discover valid IDs.'),
+    position: position.describe('Position where the node should be created (absolute diagram coordinates)'),
+    text: z.string().optional().describe('Label text to use in case the given element type allows for labels.'),
+    containerId: z.string().optional().describe('ID of the container element. If not provided, node is added to the root.'),
+    // `args` stays open (`record(...)`) — adopter-specific extension surface for per-element-type creation hints.
+    args: z.record(z.string(), z.any()).optional().describe('Additional type-specific arguments for node creation (varies by element type)')
+});
+
+export const CreateNodesInputSchema = McpDiagramScopedInputSchema.extend({
+    nodes: z.array(CreateNodeSpecSchema).min(1).describe('Array of nodes to create. Must include at least one node.')
+});
+export type CreateNodesInput = z.infer<typeof CreateNodesInputSchema>;
+
+export const CreateNodesOutputSchema = z.object({
+    createdNodes: z
+        .array(ElementIdentitySchema)
+        .describe('Nodes successfully created, in input order. `label` is only present when the type actually accepted text.'),
+    errors: z.array(z.string()).describe('Per-input hard-failure messages — the creation could not complete.'),
+    warnings: z
+        .array(z.string())
+        .describe(
+            'Soft notices for inputs that succeeded with caveats (e.g. `text` supplied for a type whose elements have no editable label).'
+        )
+});
+
+@injectable()
+export class CreateNodesMcpToolHandler extends OperationMcpDiagramToolHandler<CreateNodesInput> {
+    static readonly NAME = 'create-nodes';
+    readonly name = CreateNodesMcpToolHandler.NAME;
+    override readonly title = 'Create Diagram Nodes';
+    readonly description =
+        'Create one or multiple new nodes in the diagram at the specified positions. ' +
+        'When creating new nodes absolutely consider the visual alignment with existing nodes — call ' +
+        '`query-elements` (or `count-elements` for a quick overview) first to avoid overlap. ' +
+        'Each node descriptor needs an `elementTypeId` (from `element-types`) and a `position`; ' +
+        '`text`, `containerId`, and per-type `args` are optional. ' +
+        'This operation modifies the diagram state and requires user approval.';
+    readonly inputSchema = CreateNodesInputSchema;
+    override readonly outputSchema = CreateNodesOutputSchema;
+
+    protected async createResult({ nodes }: CreateNodesInput): Promise<McpToolResult> {
+        let beforeIds = this.modelState.index.allIds();
+
+        const errors: string[] = [];
+        const warnings: string[] = [];
+        const createdNodes: ElementIdentity[] = [];
+        let dispatchedOperations = 0;
+        // Sequential — each iteration must isolate its own creation in the post-dispatch diff.
+        for (const node of nodes) {
+            const { elementTypeId, position, text, args } = node;
+            const containerId = node.containerId ? this.aliasService.lookup(node.containerId) : undefined;
+
+            // Surface as `position` (matches element properties) rather than core's `location` for AI-facing API consistency.
+            const operation = CreateNodeOperation.create(elementTypeId, { location: position, containerId, args });
+            await this.actionDispatcher.dispatch(operation);
+            dispatchedOperations++;
+
+            const afterIds = this.modelState.index.allIds();
+            const newIds = afterIds.filter(id => !beforeIds.includes(id));
+            const newElements = newIds.map(id => this.modelState.index.find(id)).filter(element => element?.type === elementTypeId);
+            const newElement = newElements[0];
+            if (newElements.length > 1) {
+                this.logger.warn('More than 1 new element created');
+            }
+            beforeIds = afterIds;
+
+            // Operations don't surface failure directly — infer from absence of a new id of the requested type.
+            if (!newElement) {
+                errors.push(`Node creation likely failed because no new element ID was found for input: ${JSON.stringify(node)}`);
+                continue;
+            }
+
+            if (text) {
+                const labelId = this.labelProvider.getLabel(newElement)?.id;
+                if (labelId) {
+                    await this.actionDispatcher.dispatch(ApplyLabelEditOperation.create({ labelId, text }));
+                    dispatchedOperations++;
+                } else {
+                    warnings.push(`Ignored \`text\` for '${elementTypeId}' — this element type has no editable label.`);
+                }
+            }
+
+            createdNodes.push(this.describeResolvedElement(newElement));
+        }
+
+        const successListStr = createdNodes
+            .map(({ id, elementTypeId, label }) => `- ${label ? `'${label}' ` : ''}${elementTypeId} (#${id})`)
+            .join('\n');
+        // Per-input errors / warnings are surfaced in `errors` / `warnings`; the call itself still
+        // succeeds — rolling back partial creates would require operation-level transactions.
+        return this.success(
+            `Successfully created ${createdNodes.length} node(s) (in ${dispatchedOperations} commands):\n${successListStr}` +
+                formatNoticeList('errors', errors) +
+                formatNoticeList('warnings', warnings),
+            { createdNodes, errors, warnings }
+        );
+    }
+}

package/src/tools/handlers/delete-elements-mcp-tool-handler.ts

@@ -0,0 +1,73 @@
+/********************************************************************************
+ * 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 { DeleteElementOperation } from '@eclipse-glsp/server';
+import { injectable } from 'inversify';
+import * as z from 'zod/v4';
+import {
+    ElementIdentitySchema,
+    McpDiagramScopedInputSchema,
+    McpToolResult,
+    OperationMcpDiagramToolHandler,
+    elementIds
+} from '../../server';
+
+export const DeleteElementsInputSchema = McpDiagramScopedInputSchema.extend({ elementIds });
+export type DeleteElementsInput = z.infer<typeof DeleteElementsInputSchema>;
+
+export const DeleteElementsOutputSchema = z.object({
+    deletedElements: z
+        .array(ElementIdentitySchema)
+        .describe(
+            'Identity of each element the LLM requested for deletion (captured before dispatch). Dependents auto-deleted by GLSP are not enumerated here.'
+        ),
+    deletedCount: z
+        .number()
+        .int()
+        .describe(
+            'Total number of elements removed from the model. Higher than `deletedElements.length` when dependents (e.g. edges) are auto-deleted.'
+        )
+});
+
+@injectable()
+export class DeleteElementsMcpToolHandler extends OperationMcpDiagramToolHandler<DeleteElementsInput> {
+    static readonly NAME = 'delete-elements';
+    readonly name = DeleteElementsMcpToolHandler.NAME;
+    override readonly title = 'Delete Diagram Elements';
+    readonly description =
+        'Delete one or more elements (nodes or edges) from the diagram. ' +
+        'This operation modifies the diagram state and requires user approval. ' +
+        'Automatically handles dependent elements (e.g., deleting a node also deletes connected edges).';
+    readonly inputSchema = DeleteElementsInputSchema;
+    override readonly outputSchema = DeleteElementsOutputSchema;
+    /** Deletion is the canonical destructive update — flip the operation-base default. */
+    override readonly destructiveHint = true;
+
+    protected async createResult({ elementIds }: DeleteElementsInput): Promise<McpToolResult> {
+        const realIds = this.resolveExistingIds(elementIds);
+        // Capture identities BEFORE dispatch — once deleted, `describeElement` returns undefined.
+        const deletedElements = realIds
+            .map(realId => this.describeElement(realId))
+            .filter((entry): entry is NonNullable<typeof entry> => entry !== undefined);
+        const beforeCount = this.modelState.index.allIds().length;
+        await this.actionDispatcher.dispatch(DeleteElementOperation.create(realIds));
+        const deletedCount = beforeCount - this.modelState.index.allIds().length;
+        return this.success(`Successfully deleted ${deletedCount} element(s) (including dependents)`, {
+            deletedElements,
+            deletedCount
+        });
+    }
+}

package/src/tools/handlers/diagram-model-mcp-tool-handler.ts

@@ -0,0 +1,66 @@
+/********************************************************************************
+ * 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 { GModelElement } from '@eclipse-glsp/server';
+import { inject, injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { McpModelSerializer } from '../../resources/services/mcp-model-serializer';
+import { McpDiagramScopedInputSchema, AbstractMcpDiagramToolHandler, McpToolResult } from '../../server';
+
+export const DiagramModelInputSchema = McpDiagramScopedInputSchema;
+export type DiagramModelInput = z.infer<typeof DiagramModelInputSchema>;
+
+/** `.loose()` lets adopter element types attach extra fields (position, size, …) without widening the schema each time. */
+export const DiagramModelElementSchema = z
+    .object({
+        id: z.string(),
+        type: z.string(),
+        parentId: z.string().optional()
+    })
+    .loose();
+
+export const DiagramModelOutputSchema = z.object({
+    sessionId: z.string(),
+    elements: z.array(DiagramModelElementSchema)
+});
+
+@injectable()
+export class DiagramModelMcpToolHandler extends AbstractMcpDiagramToolHandler<DiagramModelInput> {
+    static readonly NAME = 'diagram-model';
+    readonly name = DiagramModelMcpToolHandler.NAME;
+    override readonly title = 'Diagram Model Structure';
+    readonly description =
+        'Get the complete GLSP model for a session as a markdown structure. ' +
+        'Includes all nodes, edges, and their relevant properties. ' +
+        'For large diagrams, prefer `query-elements` (filtered listing) or `count-elements` (size summary) ' +
+        'before falling back to this full dump.';
+    readonly inputSchema = DiagramModelInputSchema;
+    override readonly outputSchema = DiagramModelOutputSchema;
+
+    @inject(McpModelSerializer) protected serializer: McpModelSerializer;
+
+    protected createResult({ sessionId }: DiagramModelInput): McpToolResult {
+        const root = this.modelState.root;
+        const structured = this.serializer.serializeStructured(root);
+        const count = Array.isArray(structured.elements) ? structured.elements.length : 0;
+        return this.success(this.summarizeModel(root, count), { sessionId, ...structured });
+    }
+
+    /** Builds the LLM-facing summary line. Override to customize per-adopter wording. */
+    protected summarizeModel(root: GModelElement, elementCount: number): string {
+        return `Diagram '${this.aliasService.alias(root.id)}' (${root.type}): ${elementCount} element(s) total. Full structure in structuredContent.`;
+    }
+}

package/src/tools/handlers/element-types-mcp-tool-handler.ts

@@ -0,0 +1,151 @@
+/********************************************************************************
+ * 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 {
+    ClientSessionInitializer,
+    ClientSessionManager,
+    DiagramModules,
+    InjectionContainer,
+    createClientSessionModule
+} from '@eclipse-glsp/server';
+import { Container, ContainerModule, inject, injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { AbstractMcpToolHandler, McpToolError, McpToolResult } from '../../server';
+import { ElementTypes, ElementTypesProvider } from '../../resources/services/element-types-provider';
+
+export const ElementTypesInputSchema = z.object({
+    sessionId: z.string().optional().describe('Open GLSP session id; diagram type is derived from it. Provide this OR `diagramType`.'),
+    diagramType: z.string().optional().describe('Diagram type to query. Provide this OR `sessionId`; useful when no session is open yet.')
+});
+export type ElementTypesInput = z.infer<typeof ElementTypesInputSchema>;
+
+/**
+ * `id` + `label` are required (the default registry-scrape provides both); `description` and
+ * `acceptsText` are optional adopter-richer fields. `.loose()` lets adopter providers attach
+ * arbitrary extra fields without us having to widen the schema each time.
+ */
+export const ElementTypeEntrySchema = z
+    .object({
+        id: z.string().describe('Element type id used by `create-*` tools (e.g. `task:manual`).'),
+        label: z.string().describe('Human-readable display name for the element TYPE (e.g. `Manual Task`).'),
+        description: z.string().optional().describe('Adopter-supplied human-readable description.'),
+        acceptsText: z
+            .boolean()
+            .optional()
+            .describe('Whether `create-*` / `modify-*` tools should pass a `text` arg for elements of this type. Absent ⇒ unknown.')
+    })
+    .loose();
+
+export const ElementTypesOutputSchema = z.object({
+    diagramType: z.string(),
+    nodeTypes: z.array(ElementTypeEntrySchema),
+    edgeTypes: z.array(ElementTypeEntrySchema)
+});
+
+/**
+ * Server-scope so the LLM can discover types before opening a session. Lazy-harvests the
+ * per-diagram-type {@link ElementTypesProvider} via a temporary child container (same pattern
+ * as core's `DefaultGlobalActionProvider`) and caches the result for the server's lifetime —
+ * element-type sets are static at runtime, so we pay the harvest cost once per type.
+ *
+ * Adopters with statically-known type info bind their own {@link ElementTypesProvider} via
+ * `bindElementTypesProvider()`; the harvest picks it up without further overrides.
+ */
+@injectable()
+export class ElementTypesMcpToolHandler extends AbstractMcpToolHandler<ElementTypesInput> {
+    @inject(DiagramModules) protected diagramModules: Map<string, ContainerModule[]>;
+    @inject(InjectionContainer) protected serverContainer: Container;
+    @inject(ClientSessionManager) protected clientSessionManager: ClientSessionManager;
+
+    static readonly NAME = 'element-types';
+    readonly name = ElementTypesMcpToolHandler.NAME;
+    override readonly title = 'Creatable Element Types';
+    readonly description =
+        'List all element types (nodes and edges) that can be created for a specific diagram type. ' +
+        'Use this to discover valid `elementTypeId` values for the create-nodes / create-edges tools. ' +
+        'Pass `sessionId` for the diagram you are working in (recommended), or `diagramType` directly ' +
+        'when no session of that type is open yet (e.g. when creating a brand-new diagram).';
+    readonly inputSchema = ElementTypesInputSchema;
+    override readonly outputSchema = ElementTypesOutputSchema;
+
+    protected readonly cache = new Map<string, ElementTypes>();
+
+    protected createResult({ sessionId, diagramType }: ElementTypesInput): McpToolResult {
+        const resolved = diagramType ?? this.resolveDiagramType(sessionId);
+        const { nodeTypes, edgeTypes } = this.getElementTypes(resolved);
+        return this.success(this.summarizeElementTypes(resolved, nodeTypes, edgeTypes), {
+            diagramType: resolved,
+            nodeTypes,
+            edgeTypes
+        });
+    }
+
+    /** Builds the LLM-facing summary. Override to customize per-adopter wording. */
+    protected summarizeElementTypes(
+        diagramType: string,
+        nodeTypes: ElementTypes['nodeTypes'],
+        edgeTypes: ElementTypes['edgeTypes']
+    ): string {
+        return (
+            `Diagram type '${diagramType}': ${nodeTypes.length} node type(s), ${edgeTypes.length} edge type(s); ` +
+            `full details in structuredContent.\n` +
+            `- Node types: ${nodeTypes.map(entry => entry.id).join(', ') || '(none)'}\n` +
+            `- Edge types: ${edgeTypes.map(entry => entry.id).join(', ') || '(none)'}`
+        );
+    }
+
+    protected resolveDiagramType(sessionId: string | undefined): string {
+        if (!sessionId) {
+            throw new McpToolError('Either `diagramType` or `sessionId` must be provided.');
+        }
+        const session = this.clientSessionManager.getSession(sessionId);
+        if (!session) {
+            throw new McpToolError(`Unknown sessionId: ${sessionId}`);
+        }
+        return session.diagramType;
+    }
+
+    protected getElementTypes(diagramType: string): ElementTypes {
+        let types = this.cache.get(diagramType);
+        if (!types) {
+            types = this.harvestElementTypes(diagramType);
+            this.cache.set(diagramType, types);
+        }
+        return types;
+    }
+
+    /** Runs session-open initializers on a throwaway container so registries (e.g. `OperationHandlerRegistry`) are populated for the provider to scrape. */
+    protected harvestElementTypes(diagramType: string): ElementTypes {
+        const modules = this.diagramModules.get(diagramType);
+        if (!modules) {
+            throw new McpToolError(`Unknown diagram type: ${diagramType}`);
+        }
+        const tempContainer = this.serverContainer.createChild();
+        try {
+            const placeholderSessionModule = createClientSessionModule({
+                clientId: 'mcp-element-types-temp',
+                glspClient: { process: () => {} },
+                clientActionKinds: []
+            });
+            tempContainer.load(...modules, placeholderSessionModule);
+            const initializers = tempContainer.getAll<ClientSessionInitializer>(ClientSessionInitializer);
+            initializers.forEach(initializer => initializer.initialize());
+            return tempContainer.get<ElementTypesProvider>(ElementTypesProvider).get();
+        } finally {
+            tempContainer.unbindAll();
+        }
+    }
+}

package/src/tools/handlers/get-selection-mcp-tool-handler.ts

@@ -0,0 +1,54 @@
+/********************************************************************************
+ * 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 { ActionDispatcher, GetSelectionAction } from '@eclipse-glsp/server';
+import { inject, injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { McpDiagramScopedInputSchema, AbstractMcpDiagramToolHandler, McpToolResult, requestActionOrFail } from '../../server';
+
+export const GetSelectionInputSchema = McpDiagramScopedInputSchema;
+export type GetSelectionInput = z.infer<typeof GetSelectionInputSchema>;
+
+export const GetSelectionOutputSchema = z.object({
+    selectedElementIds: z.array(z.string()).describe('Aliased ids of the elements currently selected on the client.')
+});
+
+/** Round-trips a sprotty {@link GetSelectionAction} via `ActionDispatcher.requestUntil` and awaits the matching `SelectionResult`. */
+@injectable()
+export class GetSelectionMcpToolHandler extends AbstractMcpDiagramToolHandler<GetSelectionInput> {
+    /** Timeout (in ms) for awaiting the selection response from the client. Override via subclass + rebind. */
+    protected readonly timeoutMs: number = 5000;
+
+    static readonly NAME = 'get-selection';
+    readonly name = GetSelectionMcpToolHandler.NAME;
+    override readonly title = 'Get Selected Diagram Elements';
+    readonly description =
+        'Get the element IDs of all elements currently selected in the user-facing diagram UI. ' +
+        'Use this only when the user explicitly references their selection ("the selected node", "what I have highlighted"); ' +
+        'do not call it speculatively. Pairs with `set-selection` for write-side selection control. ' +
+        'Returns an empty list when nothing is selected.';
+    readonly inputSchema = GetSelectionInputSchema;
+    override readonly outputSchema = GetSelectionOutputSchema;
+
+    @inject(ActionDispatcher) protected actionDispatcher: ActionDispatcher;
+
+    protected async createResult(_params: GetSelectionInput): Promise<McpToolResult> {
+        const response = await requestActionOrFail(this.actionDispatcher, GetSelectionAction.create(), this.timeoutMs, this.name);
+        const selectedElementIds = this.encodeIds(response.selectedElementsIDs);
+        const selectedIdsStr = selectedElementIds.map(id => `- ${id}`).join('\n');
+        return this.success(`Following element IDs are selected:\n${selectedIdsStr}`, { selectedElementIds });
+    }
+}