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

package/src/common/tools/handlers/modify-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, ChangeBoundsOperation, GEdge, GShapeElement } from '@eclipse-glsp/server';
+import { ApplyLabelEditOperation, ChangeBoundsOperation, GEdge, GModelRoot, GNode } from '@eclipse-glsp/server';
 import { injectable } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolError, McpToolResult } from '../../server/mcp-handler-shared';
@@ -37,7 +37,13 @@ export const NodeSizeSchema = z.strictObject({
 /** Single node-modification entry. Strict so an LLM-typoed field surfaces as a validation error instead of being silently dropped. */
 export const ModifyNodeSpecSchema = z.strictObject({
     elementId,
-    position: position.optional().describe('Position where the node should be moved to (absolute diagram coordinates)'),
+    position: position
+        .optional()
+        .describe(
+            'Position where the node should be moved to, relative to the parent element ' +
+                '(identical to absolute diagram coordinates for direct children of the root, which is the common case). ' +
+                'Matches the `position` reported by `query-elements`. Note `create-nodes` takes absolute coordinates instead.'
+        ),
     size: NodeSizeSchema.optional().describe('New size of the node'),
     text: z.string().optional().describe("Label text to use instead (given that the element's type allows for labels).")
 });
@@ -55,15 +61,17 @@ export const ModifyNodesOutputSchema = z.object({
         .array(ElementIdentitySchema)
         .describe('Identity of each node whose change request was dispatched (post-modification labels).'),
     dispatchedCommands,
+    errors: z.array(z.string()).describe('Per-input failure messages; absent or empty when every input succeeded.'),
     warnings: z
         .array(z.string())
         .describe(
             'Soft notices for inputs whose change applied with caveats (e.g. `text` supplied for a node whose type has no editable label).'
         )
 });
+export type ModifyNodesOutput = z.infer<typeof ModifyNodesOutputSchema>;
 
 @injectable()
-export class ModifyNodesMcpToolHandler extends OperationMcpDiagramToolHandler<ModifyNodesInput> {
+export class ModifyNodesMcpToolHandler extends OperationMcpDiagramToolHandler<ModifyNodesInput, ModifyNodesOutput> {
     static readonly NAME = 'modify-nodes';
     readonly name = ModifyNodesMcpToolHandler.NAME;
     override readonly title = 'Modify Diagram Nodes';
@@ -88,53 +96,83 @@ export class ModifyNodesMcpToolHandler extends OperationMcpDiagramToolHandler<Mo
             throw new McpToolError(`modify-nodes does not accept edges — got: ${wrongType.join(', ')}. Use modify-edges for edges.`);
         }
 
-        // Reject any other non-shape kinds (labels, compartments, ports, custom kinds) — they
-        // reach the index too and would silently produce no-op or undefined-bounds operations.
-        const nonShape = elements.filter(([, element]) => !(element instanceof GShapeElement)).map(([change]) => `'${change.elementId}'`);
-        if (nonShape.length) {
+        // The root has no bounds of its own, and a `text` edit against it would rename whatever
+        // top-level `GLabel` the label provider happens to find first.
+        const roots = elements.filter(([, element]) => element instanceof GModelRoot).map(([change]) => `'${change.elementId}'`);
+        if (roots.length) {
+            throw new McpToolError(
+                `modify-nodes does not accept the diagram root — got: ${roots.join(', ')}. Target a node inside the diagram instead.`
+            );
+        }
+
+        // Core's `GModelChangeBoundsOperationHandler` only applies bounds to a `GNode`
+        // (`findByClass`). Label-only edits stay open to every element kind.
+        const unmovable = elements
+            .filter(([change, element]) => (change.position || change.size) && !(element instanceof GNode))
+            .map(([change, element]) => `'${change.elementId}' (type '${element.type}')`);
+        if (unmovable.length) {
             throw new McpToolError(
-                `modify-nodes only accepts shape elements — got: ${nonShape.join(', ')}. ` +
-                    'Use `query-elements` (inspect mode) to find shape ids, or pick the parent shape.'
+                `modify-nodes can only change \`position\` / \`size\` of nodes — got: ${unmovable.join(', ')}. ` +
+                    'Use `query-elements` (inspect mode) to find node ids, or target the parent node.'
             );
         }
 
-        // Modifications are independent of each other — dispatch in parallel.
-        const promises: Promise<void>[] = [];
+        // Modifications are independent of each other — dispatch in parallel. `allSettled` so one
+        // failed dispatch surfaces in `errors` instead of rejecting the whole call and losing the
+        // other outcomes, which have already mutated the model.
+        const dispatched: Array<{ promise: Promise<void>; inputId: string }> = [];
+        const errors: string[] = [];
         const warnings: string[] = [];
         elements.forEach(([change, element]) => {
-            // Guaranteed non-null and shape-typed by the missing-elements / nonShape checks above.
-            const resolved = element as GShapeElement;
             const { size, position, text } = change;
             const realId = this.aliasService.lookup(change.elementId);
 
-            if (size || position) {
-                const newSize = size ?? resolved.size;
-                const newPosition = position ?? resolved.position;
+            if (!size && !position && !text) {
+                errors.push(`No change requested for node '${change.elementId}' — provide \`position\`, \`size\` or a non-empty \`text\`.`);
+                return;
+            }
+
+            if ((size || position) && element instanceof GNode) {
+                const newSize = size ?? element.size;
+                const newPosition = position ?? element.position;
 
                 const operation = ChangeBoundsOperation.create([{ elementId: realId, newSize, newPosition }]);
-                promises.push(this.actionDispatcher.dispatch(operation));
+                dispatched.push({ promise: this.actionDispatcher.dispatch(operation), inputId: change.elementId });
             }
 
             if (text) {
-                const labelId = this.labelProvider.getLabel(resolved)?.id;
+                const labelId = this.labelProvider.getLabel(element)?.id;
                 if (labelId) {
-                    promises.push(this.actionDispatcher.dispatch(ApplyLabelEditOperation.create({ labelId, text })));
+                    const operation = ApplyLabelEditOperation.create({ labelId, text });
+                    dispatched.push({ promise: this.actionDispatcher.dispatch(operation), inputId: change.elementId });
                 } else {
                     warnings.push(
-                        `Ignored \`text\` for '${change.elementId}' (type '${resolved.type}') — this element has no editable label.`
+                        `Ignored \`text\` for '${change.elementId}' (type '${element.type}') — this element has no editable label.`
                     );
                 }
             }
         });
 
-        await Promise.all(promises);
+        const results = await Promise.allSettled(dispatched.map(entry => entry.promise));
+        const modifiedInputIds = new Set<string>();
+        results.forEach((result, index) => {
+            const { inputId } = dispatched[index];
+            if (result.status === 'rejected') {
+                const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+                errors.push(`Failed to modify node '${inputId}': ${reason}`);
+            } else {
+                modifiedInputIds.add(inputId);
+            }
+        });
 
-        const modifiedNodes = nodes
-            .map(change => this.describeElement(change.elementId))
+        const modifiedNodes = [...modifiedInputIds]
+            .map(inputId => this.describeElement(inputId))
             .filter((entry): entry is NonNullable<typeof entry> => entry !== undefined);
         return this.success(
-            `Successfully modified ${nodes.length} node(s) (in ${promises.length} commands)` + formatNoticeList('warnings', warnings),
-            { modifiedNodes, dispatchedCommands: promises.length, warnings }
+            `Successfully modified ${modifiedNodes.length} node(s) (in ${dispatched.length} commands)` +
+                formatNoticeList('errors', errors) +
+                formatNoticeList('warnings', warnings),
+            { modifiedNodes, dispatchedCommands: dispatched.length, errors, warnings }
         );
     }
 }

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

@@ -60,10 +60,11 @@ export const QueryElementsOutputSchema = z.object({
                 'The `elements` array then includes the container plus its descendants.'
         )
 });
+export type QueryElementsOutput = z.infer<typeof QueryElementsOutputSchema>;
 
 /** Two-mode element query — list/filter or inspect-by-id, discriminated by `elementIds` presence. */
 @injectable()
-export class QueryElementsMcpToolHandler extends AbstractMcpDiagramToolHandler<QueryElementsInput> {
+export class QueryElementsMcpToolHandler extends AbstractMcpDiagramToolHandler<QueryElementsInput, QueryElementsOutput> {
     static readonly NAME = 'query-elements';
     readonly name = QueryElementsMcpToolHandler.NAME;
     override readonly title = 'Query Diagram Elements';

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

@@ -22,19 +22,20 @@ import { McpDiagramScopedInputSchema } from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 
 export const RedoInputSchema = McpDiagramScopedInputSchema.extend({
-    commandsToRedo: z.number().min(1).default(1).describe('Number of commands to redo. Defaults to 1 (most recent undone command).')
+    commandsToRedo: z.number().int().min(1).default(1).describe('Number of commands to redo. Defaults to 1 (most recent undone command).')
 });
 export type RedoInput = z.infer<typeof RedoInputSchema>;
 
 export const RedoOutputSchema = z.object({
     commandsRedone: z.number().int().describe('Number of previously-undone commands re-applied.')
 });
+export type RedoOutput = z.infer<typeof RedoOutputSchema>;
 
 /**
  * Redo a given number of the most recent undone actions on the command stack.
  */
 @injectable()
-export class RedoMcpToolHandler extends OperationMcpDiagramToolHandler<RedoInput> {
+export class RedoMcpToolHandler extends OperationMcpDiagramToolHandler<RedoInput, RedoOutput> {
     static readonly NAME = 'redo';
     readonly name = RedoMcpToolHandler.NAME;
     override readonly title = 'Redo Diagram Commands';
@@ -55,10 +56,14 @@ export class RedoMcpToolHandler extends OperationMcpDiagramToolHandler<RedoInput
             );
         }
 
-        for (let i = 0; i < commandsToRedo; i++) {
+        // The stack may hold fewer commands than requested.
+        let commandsRedone = 0;
+        while (commandsRedone < commandsToRedo && this.commandStack.canRedo()) {
             await this.actionDispatcher.dispatch(RedoAction.create());
+            commandsRedone++;
         }
 
-        return this.success('Redo successful', { commandsRedone: commandsToRedo });
+        const shortfall = commandsRedone < commandsToRedo ? ` (${commandsToRedo} requested; the redo stack held no more commands)` : '';
+        return this.success(`Redo successful: re-applied ${commandsRedone} command(s)${shortfall}`, { commandsRedone });
     }
 }

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

@@ -34,10 +34,11 @@ export const SaveModelOutputSchema = z.object({
         .optional()
         .describe('Destination file URI when explicitly provided; absent when saving to the original source location.')
 });
+export type SaveModelOutput = z.infer<typeof SaveModelOutputSchema>;
 
 /** Doesn't extend `OperationMcpDiagramToolHandler` — saving a read-only model is a legitimate adopter scenario (e.g. "save as" to a writable location). */
 @injectable()
-export class SaveModelMcpToolHandler extends AbstractMcpDiagramToolHandler<SaveModelInput> {
+export class SaveModelMcpToolHandler extends AbstractMcpDiagramToolHandler<SaveModelInput, SaveModelOutput> {
     static readonly NAME = 'save-model';
     readonly name = SaveModelMcpToolHandler.NAME;
     override readonly title = 'Save Diagram Model';
@@ -62,7 +63,9 @@ export class SaveModelMcpToolHandler extends AbstractMcpDiagramToolHandler<SaveM
     @inject(McpLogger) protected mcpLogger: McpLogger;
 
     protected async createResult({ fileUri }: SaveModelInput): Promise<McpToolResult> {
-        if (!this.commandStack.isDirty) {
+        // Only save-in-place can be short-circuited: a "save as" destination has no copy yet,
+        // dirty or not.
+        if (!fileUri && !this.commandStack.isDirty) {
             this.mcpLogger.info('save-model: nothing to save');
             return this.success('No changes to save', { saved: false, fileUri });
         }

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

@@ -40,9 +40,10 @@ export type SessionInfoRow = z.infer<typeof SessionInfoRowSchema>;
 export const SessionInfoOutputSchema = z.object({
     sessions: z.array(SessionInfoRowSchema)
 });
+export type SessionInfoOutput = z.infer<typeof SessionInfoOutputSchema>;
 
 @injectable()
-export class SessionInfoMcpToolHandler extends AbstractMcpToolHandler<SessionInfoInput> {
+export class SessionInfoMcpToolHandler extends AbstractMcpToolHandler<SessionInfoInput, SessionInfoOutput> {
     @inject(ClientSessionManager) protected clientSessionManager: ClientSessionManager;
 
     static readonly NAME = 'session-info';

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

@@ -18,14 +18,16 @@ import { ActionDispatcher, SelectAction, SelectAllAction } from '@eclipse-glsp/s
 import { inject, injectable } from 'inversify';
 import * as z from 'zod/v4';
 import { McpToolResult } from '../../server/mcp-handler-shared';
-import { McpDiagramScopedInputSchema, elementIds } from '../../server/mcp-input-schemas';
+import { McpDiagramScopedInputSchema, elementIdsAllowingEmpty } from '../../server/mcp-input-schemas';
 import { AbstractMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 
 export const SetSelectionInputSchema = McpDiagramScopedInputSchema.extend({
-    selectedElementIds: elementIds
+    selectedElementIds: elementIdsAllowingEmpty
         .optional()
-        .describe('Element IDs to select. Pass an empty array (or omit + set `clear: true`) to clear the selection.'),
-    deselectedElementIds: elementIds.optional().describe('Element IDs to remove from the selection. Used to subtract without replacing.'),
+        .describe('Element IDs to select. Pass an empty array (or omit the field) together with `clear: true` to clear the selection.'),
+    deselectedElementIds: elementIdsAllowingEmpty
+        .optional()
+        .describe('Element IDs to remove from the selection. Used to subtract without replacing.'),
     clear: z
         .boolean()
         .optional()
@@ -38,6 +40,7 @@ export const SetSelectionOutputSchema = z.object({
     deselectedElementIds: z.array(z.string()).describe('Aliased ids requested for deselection.'),
     cleared: z.boolean().describe('Whether the existing selection was cleared before applying.')
 });
+export type SetSelectionOutput = z.infer<typeof SetSelectionOutputSchema>;
 
 /**
  * Pushes a selection change to the client. Counterpart to `get-selection` — useful for the
@@ -48,7 +51,7 @@ export const SetSelectionOutputSchema = z.object({
  * even though the underlying GModel is unaffected.
  */
 @injectable()
-export class SetSelectionMcpToolHandler extends AbstractMcpDiagramToolHandler<SetSelectionInput> {
+export class SetSelectionMcpToolHandler extends AbstractMcpDiagramToolHandler<SetSelectionInput, SetSelectionOutput> {
     static readonly NAME = 'set-selection';
     readonly name = SetSelectionMcpToolHandler.NAME;
     override readonly title = 'Set Diagram Selection';

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

@@ -74,9 +74,10 @@ export const SetViewOutputSchema = z.object({
         .optional()
         .describe("Resolved final viewport when `action: 'set-viewport'` was applied (current values merged with the supplied overrides).")
 });
+export type SetViewOutput = z.infer<typeof SetViewOutputSchema>;
 
 @injectable()
-export class SetViewMcpToolHandler extends AbstractMcpDiagramToolHandler<SetViewInput> {
+export class SetViewMcpToolHandler extends AbstractMcpDiagramToolHandler<SetViewInput, SetViewOutput> {
     /** Timeout (in ms) for the `GetViewportAction` round-trip used by `set-viewport` partial updates. Override via subclass + rebind. */
     protected readonly viewportQueryTimeoutMs: number = 5000;
 
@@ -102,7 +103,7 @@ export class SetViewMcpToolHandler extends AbstractMcpDiagramToolHandler<SetView
         if (action === 'set-viewport') {
             return this.applyExplicitViewport(zoom, scroll);
         }
-        const resolvedIds = elementIds ? elementIds.map(id => this.aliasService.lookup(id)) : this.modelState.index.allIds();
+        const resolvedIds = elementIds ? this.resolveExistingIds(elementIds) : this.modelState.index.allIds();
         const dispatchAction = this.buildIntentAction(action, resolvedIds);
         await this.actionDispatcher.dispatch(dispatchAction);
         return this.success('Viewport successfully changed', { action, targetIds: this.encodeIds(resolvedIds) });

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

@@ -22,19 +22,20 @@ import { McpDiagramScopedInputSchema } from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 
 export const UndoInputSchema = McpDiagramScopedInputSchema.extend({
-    commandsToUndo: z.number().min(1).default(1).describe('Number of commands to undo. Defaults to 1 (most recent command).')
+    commandsToUndo: z.number().int().min(1).default(1).describe('Number of commands to undo. Defaults to 1 (most recent command).')
 });
 export type UndoInput = z.infer<typeof UndoInputSchema>;
 
 export const UndoOutputSchema = z.object({
     commandsUndone: z.number().int().describe('Number of commands actually reverted.')
 });
+export type UndoOutput = z.infer<typeof UndoOutputSchema>;
 
 /**
  * Undo a given number of the most recent actions on the command stack.
  */
 @injectable()
-export class UndoMcpToolHandler extends OperationMcpDiagramToolHandler<UndoInput> {
+export class UndoMcpToolHandler extends OperationMcpDiagramToolHandler<UndoInput, UndoOutput> {
     static readonly NAME = 'undo';
     readonly name = UndoMcpToolHandler.NAME;
     override readonly title = 'Undo Diagram Commands';
@@ -54,10 +55,14 @@ export class UndoMcpToolHandler extends OperationMcpDiagramToolHandler<UndoInput
             throw new McpToolError('Nothing to undo (undo stack is empty; the model is at its initial state for this session).');
         }
 
-        for (let i = 0; i < commandsToUndo; i++) {
+        // The stack may hold fewer commands than requested.
+        let commandsUndone = 0;
+        while (commandsUndone < commandsToUndo && this.commandStack.canUndo()) {
             await this.actionDispatcher.dispatch(UndoAction.create());
+            commandsUndone++;
         }
 
-        return this.success('Undo successful', { commandsUndone: commandsToUndo });
+        const shortfall = commandsUndone < commandsToUndo ? ` (${commandsToUndo} requested; the undo stack held no more commands)` : '';
+        return this.success(`Undo successful: reverted ${commandsUndone} command(s)${shortfall}`, { commandsUndone });
     }
 }