@eclipse-glsp/server-mcp 2.8.0-next.7 → 2.8.0

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

@@ -37,6 +37,11 @@ import { McpRequestContext, NoopMcpRequestContext } from './mcp-request-context'
 import { AbstractMcpDiagramResourceHandler, McpDiagramResourceHandlerConstructor, toParams } from './mcp-resource-handler';
 import { BaseMcpDiagramToolHandler, McpDiagramToolHandlerConstructor } from './mcp-tool-handler';
 
+/** The diagram-type support hook shared by the diagram-scope tool and resource handler bases. */
+interface DiagramTypeSupportAware {
+    isSupportedByDiagramType(): boolean;
+}
+
 /**
  * Per-diagram-type catalog of constructor lists, harvested at MCP-server start by loading each
  * diagram type's modules onto a temporary child container — same pattern as
@@ -97,11 +102,13 @@ export class DefaultMcpDiagramHandlerDispatcher implements McpDiagramHandlerDisp
 
     /**
      * Build the per-diagram-type catalog by inspecting each diagram type's module set. We don't
-     * have a real GLSP session yet — and we don't want one, because we only need the bound
+     * have a real GLSP session yet — and we don't want one, because we mostly need the bound
      * constructor *lists*, not instances. So we spin up a throwaway child container per diagram
      * type, load its modules plus a placeholder session module, and read out the multi-binding
-     * constants. No handler is instantiated; the temporary container is unbound immediately
-     * after.
+     * constants. The temporary container is unbound immediately after.
+     *
+     * Only handlers that override `isSupportedByDiagramType` are instantiated, so a handler with
+     * a `@postConstruct` sees this probe just because it opted into the support gate.
      *
      * The placeholder session module is bound with the synthetic {@link TEMPORARY_CLIENT_ID} so
      * any session-scoped `@inject(ClientId)` in module-load wiring resolves cleanly. Diagram
@@ -123,8 +130,18 @@ export class DefaultMcpDiagramHandlerDispatcher implements McpDiagramHandlerDisp
         for (const [diagramType, modules] of this.diagramModules) {
             const tempContainer = this.serverContainer.createChild();
             tempContainer.load(...modules, placeholderSessionModule);
-            const tools = getConstructorList<McpDiagramToolHandlerConstructor>(tempContainer, McpDiagramToolHandlerConstructor);
-            const resources = getConstructorList<McpDiagramResourceHandlerConstructor>(tempContainer, McpDiagramResourceHandlerConstructor);
+            const tools = this.filterSupported(
+                tempContainer,
+                getConstructorList<McpDiagramToolHandlerConstructor>(tempContainer, McpDiagramToolHandlerConstructor),
+                diagramType,
+                BaseMcpDiagramToolHandler.prototype.isSupportedByDiagramType
+            );
+            const resources = this.filterSupported(
+                tempContainer,
+                getConstructorList<McpDiagramResourceHandlerConstructor>(tempContainer, McpDiagramResourceHandlerConstructor),
+                diagramType,
+                AbstractMcpDiagramResourceHandler.prototype.isSupportedByDiagramType
+            );
             const prompts = getConstructorList<McpDiagramPromptHandlerConstructor>(tempContainer, McpDiagramPromptHandlerConstructor);
             tempContainer.unbindAll();
             catalogs.push({ diagramType, toolConstructors: tools, resourceConstructors: resources, promptConstructors: prompts });
@@ -132,6 +149,40 @@ export class DefaultMcpDiagramHandlerDispatcher implements McpDiagramHandlerDisp
         this.diagramCatalogs = catalogs;
     }
 
+    /**
+     * Drop constructors whose handler reports the diagram type can't support it, so they never
+     * reach the MCP catalog. A handler that overrides the hook is resolved against the harvest
+     * container, where `@optional()` dependencies reflect the diagram type's real bindings; one
+     * that inherits `defaultHook` or doesn't declare the hook is kept without being instantiated.
+     *
+     * Fails open: a constructor that cannot be resolved here stays in the catalog.
+     */
+    protected filterSupported<C extends interfaces.Newable<DiagramTypeSupportAware>>(
+        container: Container,
+        constructors: C[],
+        diagramType: string,
+        defaultHook: DiagramTypeSupportAware['isSupportedByDiagramType']
+    ): C[] {
+        return constructors.filter(constructor => {
+            // A duck-typed handler may not carry the hook at all; skip it rather than resolving it
+            // only to call a method that isn't there.
+            const hook = constructor.prototype.isSupportedByDiagramType;
+            if (typeof hook !== 'function' || hook === defaultHook) {
+                return true;
+            }
+            try {
+                if (container.resolve(constructor).isSupportedByDiagramType()) {
+                    return true;
+                }
+                this.logger.debug(`Diagram type '${diagramType}' does not support MCP handler '${constructor.name}'; not registering.`);
+                return false;
+            } catch (err: unknown) {
+                this.logger.debug(`Could not probe MCP handler '${constructor.name}' for diagram type '${diagramType}'; registering.`, err);
+                return true;
+            }
+        });
+    }
+
     /** True when at least one diagram type has at least one tool handler bound. */
     hasDiagramTools(): boolean {
         return this.diagramCatalogs.some(catalog => catalog.toolConstructors.length > 0);

package/src/common/server/mcp-input-schemas.ts

@@ -45,6 +45,9 @@ export const elementId = z.string();
 /** One or more element ids. Empty arrays are rejected. */
 export const elementIds = z.array(z.string()).min(1);
 
+/** Zero or more element ids, for tools where an empty array is itself meaningful (e.g. "select nothing"). */
+export const elementIdsAllowingEmpty = z.array(z.string());
+
 /** Cartesian position used by node-creation / -modification tools. */
 export const position = z
     .object({

package/src/common/server/mcp-resource-handler.ts

@@ -294,7 +294,19 @@ export abstract class AbstractMcpDiagramResourceHandler<
         return requestActionOrFail(this.actionDispatcher, request, timeoutMs, label);
     }
 
-    /** Override to opt out of registration when a runtime dependency is missing. Default: `true`. */
+    /**
+     * Whether the diagram type can support this resource at all — see
+     * {@link BaseMcpDiagramToolHandler.isSupportedByDiagramType}. Returning `false` keeps the
+     * resource out of the MCP catalog.
+     */
+    isSupportedByDiagramType(): boolean {
+        return true;
+    }
+
+    /**
+     * Override to opt out when a per-session dependency is missing. Default: `true`. Gates the
+     * per-GLSP-session registry only — see {@link BaseMcpDiagramToolHandler.canRegister}.
+     */
     canRegister(): boolean {
         return true;
     }

package/src/common/server/mcp-tool-handler.ts

@@ -26,7 +26,7 @@ import {
 } from '@eclipse-glsp/server';
 import { ToolAnnotations } from '@modelcontextprotocol/sdk/types';
 import { inject, injectable, interfaces, optional } from 'inversify';
-import { ZodObject, ZodRawShape } from 'zod/v4';
+import { ZodObject, ZodRawShape, ZodType } from 'zod/v4';
 import { GLSPMcpServer } from './glsp-mcp-server';
 import {
     McpElementsNotFoundError,
@@ -74,7 +74,7 @@ export const McpToolHandler = Symbol('McpToolHandler');
  * @experimental
  */
 @injectable()
-export abstract class BaseMcpToolHandler {
+export abstract class BaseMcpToolHandler<O extends McpStructuredContent = McpStructuredContent> {
     @inject(McpRequestContext)
     @optional()
     protected requestContext: McpRequestContext = new NoopMcpRequestContext();
@@ -95,9 +95,11 @@ export abstract class BaseMcpToolHandler {
      * Optional dual-emit schema. When set, pass the matching `structured` payload to
      * {@link success} so the framework forwards it as `structuredContent` alongside the
      * human-readable text. The MCP spec says clients SHOULD validate `structuredContent`
-     * against the declared schema, so the two MUST stay in sync.
+     * against the declared schema, so the two MUST stay in sync. Bind the `O` type parameter to
+     * `z.infer<typeof MyOutputSchema>` to have the compiler enforce that — the type ties this
+     * field and {@link success}'s payload to the same shape.
      */
-    readonly outputSchema?: ZodObject<ZodRawShape>;
+    readonly outputSchema?: ZodObject<ZodRawShape> & ZodType<O>;
     /** Optional human-friendly display name for UIs that render a friendlier label than `name`. */
     readonly title?: string;
 
@@ -187,7 +189,7 @@ export abstract class BaseMcpToolHandler {
      * Pass `structured` whenever {@link outputSchema} is declared (the spec says clients SHOULD
      * validate against the declared shape). Omit for plain text-only responses.
      */
-    protected success(message: string, structured?: McpStructuredContent): McpToolResult {
+    protected success(message: string, structured?: O): McpToolResult {
         return { isError: false, content: [{ type: 'text', text: message }], structuredContent: structured };
     }
 
@@ -220,13 +222,16 @@ export abstract class BaseMcpToolHandler {
  * @experimental
  */
 @injectable()
-export abstract class AbstractMcpToolHandler<T = Record<string, unknown>> extends BaseMcpToolHandler implements McpToolHandler {
+export abstract class AbstractMcpToolHandler<I = Record<string, unknown>, O extends McpStructuredContent = McpStructuredContent>
+    extends BaseMcpToolHandler<O>
+    implements McpToolHandler
+{
     /** Throw {@link McpToolError} for expected, user-facing errors; the base wraps. */
-    protected abstract createResult(params: T): MaybePromise<McpToolResult>;
+    protected abstract createResult(params: I): MaybePromise<McpToolResult>;
 
     registerTool(server: GLSPMcpServer): void {
         server.registerTool(this.name, this.toRegistrationConfig(), async (params, extra) =>
-            this.requestContext.run(extra, () => this.execute(() => this.createResult(params as T)))
+            this.requestContext.run(extra, () => this.execute(() => this.createResult(params as I)))
         );
     }
 }
@@ -247,14 +252,17 @@ export abstract class AbstractMcpToolHandler<T = Record<string, unknown>> extend
  * @experimental
  */
 @injectable()
-export abstract class BaseMcpDiagramToolHandler<T extends McpDiagramScopedInput = McpDiagramScopedInput> extends BaseMcpToolHandler {
+export abstract class BaseMcpDiagramToolHandler<
+    I extends McpDiagramScopedInput = McpDiagramScopedInput,
+    O extends McpStructuredContent = McpStructuredContent
+> extends BaseMcpToolHandler<O> {
     @inject(ClientId) protected clientId: string;
     @inject(ModelState) protected modelState: ModelState;
     @inject(McpIdAliasService) protected aliasService: McpIdAliasService;
     @inject(McpLabelProvider) protected labelProvider: McpLabelProvider;
 
     /** Throw {@link McpToolError} for expected errors; the base wraps. */
-    protected abstract createResult(params: T): MaybePromise<McpToolResult>;
+    protected abstract createResult(params: I): MaybePromise<McpToolResult>;
 
     /**
      * Public dispatch entry point invoked by {@link AbstractMcpServerLauncher}'s registered SDK
@@ -262,9 +270,27 @@ export abstract class BaseMcpDiagramToolHandler<T extends McpDiagramScopedInput
      * passes through; {@link OperationMcpDiagramToolHandler} enforces the readonly gate.
      * Adopters don't call this directly.
      */
-    abstract handle(params: T): Promise<McpToolResult>;
+    abstract handle(params: I): Promise<McpToolResult>;
 
-    /** Override to opt out of registration when a runtime dependency is missing. Default: `true`. */
+    /**
+     * Whether the diagram type can support this tool at all. Evaluated once per diagram type at
+     * MCP-server start against a container with that type's diagram modules loaded, so
+     * `@inject(...) @optional()` dependencies reflect its real bindings. When no registered
+     * diagram type supports the tool, it is left out of the MCP catalog entirely.
+     *
+     * Override this for statically bound dependencies (e.g. a `LayoutEngine`) and
+     * {@link canRegister} for capabilities of the connected GLSP client — the harvest container
+     * has no client, so client capabilities always read as absent here.
+     */
+    isSupportedByDiagramType(): boolean {
+        return true;
+    }
+
+    /**
+     * Override to opt out when a per-session dependency is missing. Default: `true`. Gates the
+     * per-GLSP-session registry only: the tool stays in the catalog (another session may support
+     * it) and calls against this session fail with "No tool handler '…' registered".
+     */
     canRegister(): boolean {
         return true;
     }
@@ -357,9 +383,10 @@ export abstract class BaseMcpDiagramToolHandler<T extends McpDiagramScopedInput
  */
 @injectable()
 export abstract class AbstractMcpDiagramToolHandler<
-    T extends McpDiagramScopedInput = McpDiagramScopedInput
-> extends BaseMcpDiagramToolHandler<T> {
-    handle(params: T): Promise<McpToolResult> {
+    I extends McpDiagramScopedInput = McpDiagramScopedInput,
+    O extends McpStructuredContent = McpStructuredContent
+> extends BaseMcpDiagramToolHandler<I, O> {
+    handle(params: I): Promise<McpToolResult> {
         return this.execute(() => this.createResult(params));
     }
 }
@@ -388,8 +415,9 @@ export abstract class AbstractMcpDiagramToolHandler<
  */
 @injectable()
 export abstract class OperationMcpDiagramToolHandler<
-    T extends McpDiagramScopedInput = McpDiagramScopedInput
-> extends BaseMcpDiagramToolHandler<T> {
+    I extends McpDiagramScopedInput = McpDiagramScopedInput,
+    O extends McpStructuredContent = McpStructuredContent
+> extends BaseMcpDiagramToolHandler<I, O> {
     @inject(ActionDispatcher) protected actionDispatcher: ActionDispatcher;
 
     // Operation tools mutate the model — flip the read defaults. Concrete handlers override
@@ -400,7 +428,7 @@ export abstract class OperationMcpDiagramToolHandler<
     override readonly destructiveHint: boolean = false;
     override readonly idempotentHint: boolean = false;
 
-    handle(params: T): Promise<McpToolResult> {
+    handle(params: I): Promise<McpToolResult> {
         return this.execute(() => {
             if (this.modelState.isReadonly) {
                 throw new McpReadOnlyError();
@@ -431,5 +459,5 @@ export abstract class OperationMcpDiagramToolHandler<
  * are read off `new Constructor()` at MCP-session-init for SDK catalog registration, the same
  * trick `bindOperations` uses to read `operationType`.
  */
-export type McpDiagramToolHandlerConstructor = interfaces.Newable<BaseMcpDiagramToolHandler<any>>;
+export type McpDiagramToolHandlerConstructor = interfaces.Newable<BaseMcpDiagramToolHandler<any, any>>;
 export const McpDiagramToolHandlerConstructor = Symbol('McpDiagramToolHandlerConstructor');

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

@@ -27,6 +27,7 @@ export const CountElementsOutputSchema = z.object({
     total: z.number().int().describe('Total element count across the diagram (root included).'),
     countsByType: z.record(z.string(), z.number().int()).describe('Element count grouped by `GModelElement.type`.')
 });
+export type CountElementsOutput = z.infer<typeof CountElementsOutputSchema>;
 
 /**
  * Counts elements in the diagram, grouped by type. Cheap alternative to dumping the full
@@ -34,7 +35,7 @@ export const CountElementsOutputSchema = z.object({
  * elements of type X exist".
  */
 @injectable()
-export class CountElementsMcpToolHandler extends AbstractMcpDiagramToolHandler<CountElementsInput> {
+export class CountElementsMcpToolHandler extends AbstractMcpDiagramToolHandler<CountElementsInput, CountElementsOutput> {
     static readonly NAME = 'count-elements';
     readonly name = CountElementsMcpToolHandler.NAME;
     override readonly title = 'Count Diagram Elements';

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

@@ -14,7 +14,13 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { ChangeRoutingPointsOperation, CreateEdgeOperation, DiagramConfiguration, EdgeCreationChecker } from '@eclipse-glsp/server';
+import {
+    ChangeRoutingPointsOperation,
+    CreateEdgeOperation,
+    DiagramConfiguration,
+    EdgeCreationChecker,
+    GModelElement
+} from '@eclipse-glsp/server';
 import { inject, injectable, optional } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolResult } from '../../server/mcp-handler-shared';
@@ -66,12 +72,13 @@ export const CreateEdgesOutputSchema = z.object({
         .optional()
         .describe('Per-input validation results. Present only in `dryRun` mode.')
 });
+export type CreateEdgesOutput = z.infer<typeof CreateEdgesOutputSchema>;
 
 type EdgeInput = CreateEdgesInput['edges'][number];
 type ValidationResult = z.infer<typeof CreateEdgesValidationResultSchema>;
 
 @injectable()
-export class CreateEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<CreateEdgesInput> {
+export class CreateEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<CreateEdgesInput, CreateEdgesOutput> {
     static readonly NAME = 'create-edges';
     readonly name = CreateEdgesMcpToolHandler.NAME;
     override readonly title = 'Create Diagram Edges';
@@ -106,7 +113,7 @@ export class CreateEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<Cr
                         `${result.isValid ? 'valid' : `invalid (${result.reason})`}`
                 )
                 .join('\n');
-        return this.success(summary, { createdEdges: [], errors: [], validationResults });
+        return this.success(summary, { createdEdges: [], dispatchedCommands: 0, errors: [], validationResults });
     }
 
     protected async runCreate(edges: EdgeInput[]): Promise<McpToolResult> {
@@ -137,11 +144,16 @@ export class CreateEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<Cr
             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');
+            const knownIds = new Set(beforeIds);
+            const newElements = afterIds
+                .filter(id => !knownIds.has(id))
+                .map(id => this.modelState.index.find(id))
+                .filter((element): element is GModelElement => element !== undefined);
+            // Fall back to the first new element — see `create-nodes`.
+            const typeMatches = newElements.filter(element => element.type === elementTypeId);
+            const newElement = typeMatches[0] ?? newElements[0];
+            if (newElements.length > 1 && typeMatches.length !== 1) {
+                this.logger.warn(`Ambiguous creation result for '${elementTypeId}': picked '${newElement?.id}' among new elements`);
             }
             beforeIds = afterIds;
 

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

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { ApplyLabelEditOperation, CreateNodeOperation } from '@eclipse-glsp/server';
+import { ApplyLabelEditOperation, CreateNodeOperation, GModelElement } from '@eclipse-glsp/server';
 import { injectable } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolResult } from '../../server/mcp-handler-shared';
@@ -33,7 +33,10 @@ 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)'),
+    position: position.describe(
+        'Position where the node should be created, in absolute diagram coordinates — the server converts to ' +
+            'parent-relative when `containerId` is set. Note `modify-nodes` takes parent-relative coordinates instead.'
+    ),
     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.
@@ -57,9 +60,10 @@ export const CreateNodesOutputSchema = z.object({
             'Soft notices for inputs that succeeded with caveats (e.g. `text` supplied for a type whose elements have no editable label).'
         )
 });
+export type CreateNodesOutput = z.infer<typeof CreateNodesOutputSchema>;
 
 @injectable()
-export class CreateNodesMcpToolHandler extends OperationMcpDiagramToolHandler<CreateNodesInput> {
+export class CreateNodesMcpToolHandler extends OperationMcpDiagramToolHandler<CreateNodesInput, CreateNodesOutput> {
     static readonly NAME = 'create-nodes';
     readonly name = CreateNodesMcpToolHandler.NAME;
     override readonly title = 'Create Diagram Nodes';
@@ -91,11 +95,18 @@ export class CreateNodesMcpToolHandler extends OperationMcpDiagramToolHandler<Cr
             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');
+            const knownIds = new Set(beforeIds);
+            const newElements = afterIds
+                .filter(id => !knownIds.has(id))
+                .map(id => this.modelState.index.find(id))
+                .filter((element): element is GModelElement => element !== undefined);
+            // Fall back to the first new element: the built type may differ from the requested
+            // `elementTypeId` (type hint vs. concrete GModel type). `allIds()` is pre-order, so the
+            // first entry is the created element itself rather than one of its new children.
+            const typeMatches = newElements.filter(element => element.type === elementTypeId);
+            const newElement = typeMatches[0] ?? newElements[0];
+            if (newElements.length > 1 && typeMatches.length !== 1) {
+                this.logger.warn(`Ambiguous creation result for '${elementTypeId}': picked '${newElement?.id}' among new elements`);
             }
             beforeIds = afterIds;
 

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

@@ -38,9 +38,10 @@ export const DeleteElementsOutputSchema = z.object({
         ),
     dispatchedCommands
 });
+export type DeleteElementsOutput = z.infer<typeof DeleteElementsOutputSchema>;
 
 @injectable()
-export class DeleteElementsMcpToolHandler extends OperationMcpDiagramToolHandler<DeleteElementsInput> {
+export class DeleteElementsMcpToolHandler extends OperationMcpDiagramToolHandler<DeleteElementsInput, DeleteElementsOutput> {
     static readonly NAME = 'delete-elements';
     readonly name = DeleteElementsMcpToolHandler.NAME;
     override readonly title = 'Delete Diagram Elements';

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

@@ -38,9 +38,10 @@ export const DiagramModelOutputSchema = z.object({
     sessionId: z.string(),
     elements: z.array(DiagramModelElementSchema)
 });
+export type DiagramModelOutput = z.infer<typeof DiagramModelOutputSchema>;
 
 @injectable()
-export class DiagramModelMcpToolHandler extends AbstractMcpDiagramToolHandler<DiagramModelInput> {
+export class DiagramModelMcpToolHandler extends AbstractMcpDiagramToolHandler<DiagramModelInput, DiagramModelOutput> {
     static readonly NAME = 'diagram-model';
     readonly name = DiagramModelMcpToolHandler.NAME;
     override readonly title = 'Diagram Model Structure';
@@ -57,8 +58,10 @@ export class DiagramModelMcpToolHandler extends AbstractMcpDiagramToolHandler<Di
     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 });
+        const elements = (Array.isArray(structured.elements) ? structured.elements : []) as DiagramModelOutput['elements'];
+        // Spread first so extra top-level keys from an adopter serializer still reach the client;
+        // the narrowed `elements` then satisfies the declared output type.
+        return this.success(this.summarizeModel(root, elements.length), { sessionId, ...structured, elements });
     }
 
     /** Builds the LLM-facing summary line. Override to customize per-adopter wording. */

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

@@ -55,6 +55,7 @@ export const ElementTypesOutputSchema = z.object({
     nodeTypes: z.array(ElementTypeEntrySchema),
     edgeTypes: z.array(ElementTypeEntrySchema)
 });
+export type ElementTypesOutput = z.infer<typeof ElementTypesOutputSchema>;
 
 /**
  * Server-scope so the LLM can discover types before opening a session. Lazy-harvests the
@@ -66,7 +67,7 @@ export const ElementTypesOutputSchema = z.object({
  * `bindElementTypesProvider()`; the harvest picks it up without further overrides.
  */
 @injectable()
-export class ElementTypesMcpToolHandler extends AbstractMcpToolHandler<ElementTypesInput> {
+export class ElementTypesMcpToolHandler extends AbstractMcpToolHandler<ElementTypesInput, ElementTypesOutput> {
     @inject(DiagramModules) protected diagramModules: Map<string, ContainerModule[]>;
     @inject(InjectionContainer) protected serverContainer: Container;
     @inject(ClientSessionManager) protected clientSessionManager: ClientSessionManager;
@@ -89,8 +90,10 @@ export class ElementTypesMcpToolHandler extends AbstractMcpToolHandler<ElementTy
         const { nodeTypes, edgeTypes } = this.getElementTypes(resolved);
         return this.success(this.summarizeElementTypes(resolved, nodeTypes, edgeTypes), {
             diagramType: resolved,
-            nodeTypes,
-            edgeTypes
+            // `ElementTypeEntry` stays closed so a mistyped field on an adopter provider is still a
+            // compile error; the widening to the `loose()` schema shape happens here.
+            nodeTypes: nodeTypes as ElementTypesOutput['nodeTypes'],
+            edgeTypes: edgeTypes as ElementTypesOutput['edgeTypes']
         });
     }
 

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

@@ -27,10 +27,11 @@ 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.')
 });
+export type GetSelectionOutput = z.infer<typeof GetSelectionOutputSchema>;
 
 /** Round-trips a sprotty {@link GetSelectionAction} via `ActionDispatcher.requestUntil` and awaits the matching `SelectionResult`. */
 @injectable()
-export class GetSelectionMcpToolHandler extends AbstractMcpDiagramToolHandler<GetSelectionInput> {
+export class GetSelectionMcpToolHandler extends AbstractMcpDiagramToolHandler<GetSelectionInput, GetSelectionOutput> {
     /** Timeout (in ms) for awaiting the selection response from the client. Override via subclass + rebind. */
     protected readonly timeoutMs: number = 5000;
 

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

@@ -28,10 +28,11 @@ export const LayoutOutputSchema = z.object({
     applied: z.boolean().describe('Always true on success — surfaced for parity with other operations.'),
     dispatchedCommands
 });
+export type LayoutOutput = z.infer<typeof LayoutOutputSchema>;
 
 /** Not registered by default: requires an adopter-supplied `LayoutEngine` to bind, which only some GLSP servers ship. */
 @injectable()
-export class LayoutMcpToolHandler extends OperationMcpDiagramToolHandler<LayoutInput> {
+export class LayoutMcpToolHandler extends OperationMcpDiagramToolHandler<LayoutInput, LayoutOutput> {
     static readonly NAME = 'layout';
     readonly name = LayoutMcpToolHandler.NAME;
     override readonly title = 'Auto-Layout Diagram';
@@ -47,7 +48,12 @@ export class LayoutMcpToolHandler extends OperationMcpDiagramToolHandler<LayoutI
 
     @inject(LayoutEngine) @optional() protected layoutEngine?: LayoutEngine;
 
-    /** Skip-bind when no `LayoutEngine` is bound — every dispatch would otherwise no-op. */
+    /** Keep the tool out of the MCP catalog for diagram types that bind no `LayoutEngine`. */
+    override isSupportedByDiagramType(): boolean {
+        return this.layoutEngine !== undefined;
+    }
+
+    /** Skip session registration when no `LayoutEngine` is bound — every dispatch would otherwise no-op. */
     override canRegister(): boolean {
         return this.layoutEngine !== undefined;
     }

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

@@ -55,9 +55,10 @@ export const ModifyEdgesOutputSchema = z.object({
     dispatchedCommands,
     errors: z.array(z.string()).describe('Per-input failure messages; absent or empty when every input succeeded.')
 });
+export type ModifyEdgesOutput = z.infer<typeof ModifyEdgesOutputSchema>;
 
 @injectable()
-export class ModifyEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<ModifyEdgesInput> {
+export class ModifyEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<ModifyEdgesInput, ModifyEdgesOutput> {
     static readonly NAME = 'modify-edges';
     readonly name = ModifyEdgesMcpToolHandler.NAME;
     override readonly title = 'Modify Diagram Edges';
@@ -88,7 +89,6 @@ export class ModifyEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<Mo
         // instead of rejecting the whole call and losing the other outcomes.
         const dispatched: Array<{ promise: Promise<void>; realId: string; inputId: string }> = [];
         const errors: string[] = [];
-        const modifiedRealIds = new Set<string>();
         elements.forEach(([change]) => {
             const { routingPoints } = change;
             const realId = this.aliasService.lookup(change.elementId);
@@ -114,7 +114,6 @@ export class ModifyEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<Mo
 
                 const operation = ReconnectEdgeOperation.create({ edgeElementId: realId, sourceElementId, targetElementId });
                 dispatched.push({ promise: this.actionDispatcher.dispatch(operation), realId, inputId: change.elementId });
-                modifiedRealIds.add(realId);
                 // Routing-point changes are skipped during a reconnect — the edge's path is recomputed from scratch.
                 return;
             }
@@ -122,18 +121,25 @@ export class ModifyEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<Mo
             if (routingPoints) {
                 const operation = ChangeRoutingPointsOperation.create([{ elementId: realId, newRoutingPoints: routingPoints }]);
                 dispatched.push({ promise: this.actionDispatcher.dispatch(operation), realId, inputId: change.elementId });
-                modifiedRealIds.add(realId);
+                return;
             }
+
+            errors.push(
+                `No change requested for edge '${change.elementId}' — provide \`sourceElementId\` + \`targetElementId\` ` +
+                    'to reconnect, or `routingPoints` to reroute.'
+            );
         });
 
+        // Two entries may target the same edge; one failing must not drop the other's success.
         const results = await Promise.allSettled(dispatched.map(entry => entry.promise));
+        const modifiedRealIds = new Set<string>();
         results.forEach((result, i) => {
+            const { realId, inputId } = dispatched[i];
             if (result.status === 'rejected') {
-                const { realId, inputId } = dispatched[i];
                 const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
                 errors.push(`Failed to modify edge '${inputId}': ${reason}`);
-                // The dispatch failed, so this id was *not* modified — drop it from the success list.
-                modifiedRealIds.delete(realId);
+            } else {
+                modifiedRealIds.add(realId);
             }
         });
 
@@ -141,7 +147,7 @@ export class ModifyEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<Mo
             .map(realId => this.describeElement(realId))
             .filter((entry): entry is NonNullable<typeof entry> => entry !== undefined);
         return this.success(
-            `Successfully modified ${edges.length - errors.length} edge(s) (in ${dispatched.length} commands)${formatNoticeList('errors', errors)}`,
+            `Successfully modified ${modifiedEdges.length} edge(s) (in ${dispatched.length} commands)${formatNoticeList('errors', errors)}`,
             { modifiedEdges, dispatchedCommands: dispatched.length, errors }
         );
     }