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

package/src/server/raw-http.spec.ts

@@ -0,0 +1,59 @@
+/********************************************************************************
+ * 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 * as http from 'http';
+
+export interface RawHttpResponse {
+    status: number;
+    contentType: string | undefined;
+    body: string;
+}
+
+/**
+ * Issue a raw HTTP request to a transport's listening port. Used by spec files that need
+ * to bypass the SDK Client to assert wire-level behavior (status codes, error envelopes).
+ */
+export function rawHttpRequest(
+    port: number,
+    method: 'POST' | 'GET' | 'DELETE',
+    headers: http.OutgoingHttpHeaders,
+    body?: unknown
+): Promise<RawHttpResponse> {
+    return new Promise((resolve, reject) => {
+        const req = http.request(
+            {
+                hostname: '127.0.0.1',
+                port,
+                path: '/mcp',
+                method,
+                headers: { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream', ...headers }
+            },
+            res => {
+                const chunks: Buffer[] = [];
+                res.on('data', chunk => chunks.push(chunk));
+                res.on('end', () =>
+                    resolve({
+                        status: res.statusCode ?? 0,
+                        contentType: res.headers['content-type'],
+                        body: Buffer.concat(chunks).toString('utf8')
+                    })
+                );
+            }
+        );
+        req.on('error', reject);
+        req.end(body !== undefined ? JSON.stringify(body) : undefined);
+    });
+}

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

@@ -0,0 +1,99 @@
+/********************************************************************************
+ * 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 { ClientId, GModelElement, Logger, ModelState, NullLogger } from '@eclipse-glsp/server';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import { DefaultMcpLabelProvider, McpIdAliasService, McpLabelProvider, McpToolResult } from '../../server';
+import { CountElementsMcpToolHandler } from './count-elements-mcp-tool-handler';
+
+function makeElement(id: string, type: string): GModelElement {
+    return { id, type, children: [] } as unknown as GModelElement;
+}
+
+function makeModelState(elements: GModelElement[]): ModelState {
+    const byId = new Map(elements.map(el => [el.id, el]));
+    return {
+        index: {
+            allIds: () => [...byId.keys()],
+            get: (id: string) => byId.get(id),
+            find: (id: string) => byId.get(id)
+        }
+    } as unknown as ModelState;
+}
+
+function buildHandler(elements: GModelElement[]): CountElementsMcpToolHandler {
+    const container = new Container();
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new NullLogger());
+            bind(ClientId).toConstantValue('test-session');
+            bind(ModelState).toConstantValue(makeModelState(elements));
+            bind(McpIdAliasService).toConstantValue({
+                lookup: (id: string) => id,
+                alias: (id: string) => id
+            } as McpIdAliasService);
+            bind(McpLabelProvider).to(DefaultMcpLabelProvider);
+            bind(CountElementsMcpToolHandler).toSelf();
+        })
+    );
+    return container.get(CountElementsMcpToolHandler);
+}
+
+function callCreateResult(handler: CountElementsMcpToolHandler): Promise<McpToolResult> {
+    return (handler as unknown as { createResult: (params: { sessionId: string }) => Promise<McpToolResult> }).createResult({
+        sessionId: 'test-session'
+    });
+}
+
+describe('CountElementsMcpToolHandler', () => {
+    it('aggregates element counts grouped by `type`', async () => {
+        const handler = buildHandler([
+            makeElement('n1', 'task:manual'),
+            makeElement('n2', 'task:manual'),
+            makeElement('n3', 'task:automated'),
+            makeElement('e1', 'edge')
+        ]);
+
+        const result = await callCreateResult(handler);
+        expect(result.structuredContent).to.deep.equal({
+            total: 4,
+            countsByType: { 'task:manual': 2, 'task:automated': 1, edge: 1 }
+        });
+    });
+
+    it('orders rendered rows by count desc, then type alpha asc on ties', async () => {
+        const handler = buildHandler([
+            makeElement('e1', 'edge'),
+            makeElement('e2', 'edge'),
+            makeElement('n1', 'task:automated'),
+            makeElement('n2', 'task:manual'),
+            makeElement('n3', 'task:manual')
+        ]);
+
+        const result = await callCreateResult(handler);
+        const text = (result.content[0] as { text: string }).text;
+        // Counts: edge=2, task:manual=2, task:automated=1.
+        // Expected order: edge before task:manual (alpha tiebreak on count=2), then task:automated.
+        const expectedOrder = ['edge', 'task:manual', 'task:automated'];
+        const indices = expectedOrder.map(type => text.indexOf(`- ${type}: `));
+        expect(
+            indices.every(i => i >= 0),
+            'expected all type rows to be rendered'
+        ).to.equal(true);
+        expect(indices).to.deep.equal([...indices].sort((a, b) => a - b));
+    });
+});

package/src/tools/handlers/count-elements-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 { injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { McpDiagramScopedInputSchema, AbstractMcpDiagramToolHandler, McpToolResult } from '../../server';
+
+export const CountElementsInputSchema = McpDiagramScopedInputSchema;
+export type CountElementsInput = z.infer<typeof CountElementsInputSchema>;
+
+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`.')
+});
+
+/**
+ * Counts elements in the diagram, grouped by type. Cheap alternative to dumping the full
+ * `diagram-model` resource when the agent only needs to know "how big is this" or "do any
+ * elements of type X exist".
+ */
+@injectable()
+export class CountElementsMcpToolHandler extends AbstractMcpDiagramToolHandler<CountElementsInput> {
+    static readonly NAME = 'count-elements';
+    readonly name = CountElementsMcpToolHandler.NAME;
+    override readonly title = 'Count Diagram Elements';
+    readonly description =
+        'Count the elements in the session diagram, grouped by element type. ' +
+        'Cheap sizing primitive — useful before deciding whether to load the full model with `diagram-model` ' +
+        '(expensive on large diagrams) or whether a filtered `query-elements` call would suffice. ' +
+        'Returns total count plus a per-type breakdown.';
+    readonly inputSchema = CountElementsInputSchema;
+    override readonly outputSchema = CountElementsOutputSchema;
+
+    protected async createResult(_params: CountElementsInput): Promise<McpToolResult> {
+        const countsByType: Record<string, number> = {};
+        let total = 0;
+        for (const id of this.modelState.index.allIds()) {
+            const element = this.modelState.index.get(id);
+            if (!element) {
+                continue;
+            }
+            countsByType[element.type] = (countsByType[element.type] ?? 0) + 1;
+            total += 1;
+        }
+        return this.success(this.renderMarkdown(total, countsByType), { total, countsByType });
+    }
+
+    protected renderMarkdown(total: number, countsByType: Record<string, number>): string {
+        const sorted = Object.entries(countsByType).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+        const rows = sorted.map(([type, count]) => `- ${type}: ${count}`).join('\n');
+        return `Total elements: ${total}\n\nBy type:\n${rows}`;
+    }
+}

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

@@ -0,0 +1,196 @@
+/********************************************************************************
+ * 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,
+    ClientId,
+    DiagramConfiguration,
+    EdgeCreationChecker,
+    EdgeTypeHint,
+    GModelElement,
+    Logger,
+    ModelState,
+    NullLogger
+} from '@eclipse-glsp/server';
+import { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import { DefaultMcpLabelProvider, McpIdAliasService, McpLabelProvider, McpToolResult } from '../../server';
+import { CreateEdgesInput, CreateEdgesMcpToolHandler } from './create-edges-mcp-tool-handler';
+
+function makeElement(id: string, type: string): GModelElement {
+    return { id, type, children: [] } as unknown as GModelElement;
+}
+
+function makeModelState(elements: GModelElement[]): ModelState {
+    const byId = new Map(elements.map(el => [el.id, el]));
+    return {
+        index: {
+            allIds: () => [...byId.keys()],
+            get: (id: string) => byId.get(id),
+            find: (id: string) => byId.get(id)
+        },
+        isReadonly: false
+    } as unknown as ModelState;
+}
+
+class StubEdgeCreationChecker implements EdgeCreationChecker {
+    public lastTargetCall?: { edgeType: string; source: GModelElement; target: GModelElement };
+    constructor(private readonly result: boolean) {}
+    isValidSource(): boolean {
+        return this.result;
+    }
+    isValidTarget(edgeType: string, source: GModelElement, target: GModelElement): boolean {
+        this.lastTargetCall = { edgeType, source, target };
+        return this.result;
+    }
+}
+
+interface BuildArgs {
+    elements: GModelElement[];
+    edgeTypeHints: Pick<EdgeTypeHint, 'elementTypeId' | 'dynamic'>[];
+    checker?: EdgeCreationChecker;
+}
+
+/** Records dispatched actions so create-mode tests can assert no dispatch happened. */
+class RecordingDispatcher {
+    public dispatched: Action[] = [];
+    async dispatch(action: Action): Promise<void> {
+        this.dispatched.push(action);
+    }
+    async dispatchAll(): Promise<void> {
+        // not used by create-edges
+    }
+    dispatchAfterNextUpdate(): void {
+        // not used
+    }
+}
+
+function buildHandler({ elements, edgeTypeHints, checker }: BuildArgs): {
+    handler: CreateEdgesMcpToolHandler;
+    dispatcher: RecordingDispatcher;
+} {
+    const dispatcher = new RecordingDispatcher();
+    const container = new Container();
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new NullLogger());
+            bind(ClientId).toConstantValue('test-session');
+            bind(ModelState).toConstantValue(makeModelState(elements));
+            bind(McpIdAliasService).toConstantValue({
+                lookup: (id: string) => id,
+                alias: (id: string) => id
+            } as McpIdAliasService);
+            bind(DiagramConfiguration).toConstantValue({ edgeTypeHints } as unknown as DiagramConfiguration);
+            bind(ActionDispatcher).toConstantValue(dispatcher as unknown as ActionDispatcher);
+            if (checker) {
+                bind(EdgeCreationChecker).toConstantValue(checker);
+            }
+            bind(McpLabelProvider).to(DefaultMcpLabelProvider);
+            bind(CreateEdgesMcpToolHandler).toSelf();
+        })
+    );
+    return { handler: container.get(CreateEdgesMcpToolHandler), dispatcher };
+}
+
+function callCreateResult(handler: CreateEdgesMcpToolHandler, params: CreateEdgesInput): Promise<McpToolResult> {
+    return (handler as unknown as { createResult: (p: CreateEdgesInput) => Promise<McpToolResult> }).createResult(params);
+}
+
+interface DryRunStructured {
+    createdEdges: { id: string; elementTypeId: string; label?: string }[];
+    errors: string[];
+    validationResults: { edgeType: string; sourceElementId: string; targetElementId: string; isValid: boolean; reason?: string }[];
+}
+
+describe('CreateEdgesMcpToolHandler · dryRun', () => {
+    const baseInput = (overrides: Partial<CreateEdgesInput> = {}): CreateEdgesInput => ({
+        sessionId: 's',
+        dryRun: true,
+        edges: [{ elementTypeId: 'edge:dynamic', sourceElementId: 's', targetElementId: 't' }],
+        ...overrides
+    });
+
+    it('returns isValid:true with a "no dynamic hint" reason when the edgeType has no dynamic hint', async () => {
+        const { handler, dispatcher } = buildHandler({
+            elements: [makeElement('s', 'task'), makeElement('t', 'task')],
+            edgeTypeHints: [{ elementTypeId: 'edge:static', dynamic: false }]
+        });
+
+        const result = await callCreateResult(
+            handler,
+            baseInput({ edges: [{ elementTypeId: 'edge:static', sourceElementId: 's', targetElementId: 't' }] })
+        );
+
+        const structured = result.structuredContent as unknown as DryRunStructured;
+        expect(structured.validationResults).to.have.lengthOf(1);
+        expect(structured.validationResults[0].isValid).to.equal(true);
+        expect(structured.validationResults[0].reason).to.match(/no dynamic edge-type hint/i);
+        expect(structured.createdEdges).to.deep.equal([]);
+        expect(dispatcher.dispatched).to.have.lengthOf(0);
+    });
+
+    it('flags isValid:false with a config-gap reason when edgeType declares a dynamic hint but no checker is bound', async () => {
+        const { handler, dispatcher } = buildHandler({
+            elements: [makeElement('s', 'task'), makeElement('t', 'task')],
+            edgeTypeHints: [{ elementTypeId: 'edge:dynamic', dynamic: true }]
+        });
+
+        const result = await callCreateResult(handler, baseInput());
+
+        const structured = result.structuredContent as unknown as DryRunStructured;
+        expect(structured.validationResults[0].isValid).to.equal(false);
+        expect(structured.validationResults[0].reason).to.include('EdgeCreationChecker is not bound');
+        expect(dispatcher.dispatched).to.have.lengthOf(0);
+    });
+
+    it('delegates to EdgeCreationChecker.isValidTarget when target + dynamic hint + checker are present', async () => {
+        const sourceElement = makeElement('s', 'task');
+        const targetElement = makeElement('t', 'task');
+        const checker = new StubEdgeCreationChecker(false);
+        const { handler, dispatcher } = buildHandler({
+            elements: [sourceElement, targetElement],
+            edgeTypeHints: [{ elementTypeId: 'edge:dynamic', dynamic: true }],
+            checker
+        });
+
+        const result = await callCreateResult(handler, baseInput());
+
+        expect(checker.lastTargetCall).to.deep.equal({
+            edgeType: 'edge:dynamic',
+            source: sourceElement,
+            target: targetElement
+        });
+        const structured = result.structuredContent as unknown as DryRunStructured;
+        expect(structured.validationResults[0].isValid).to.equal(false);
+        expect(dispatcher.dispatched).to.have.lengthOf(0);
+    });
+
+    it('reports source/target not-found inline as a per-edge validation failure (does not throw)', async () => {
+        const { handler } = buildHandler({
+            elements: [makeElement('s', 'task')],
+            edgeTypeHints: [{ elementTypeId: 'edge:dynamic', dynamic: true }]
+        });
+
+        const result = await callCreateResult(
+            handler,
+            baseInput({ edges: [{ elementTypeId: 'edge:dynamic', sourceElementId: 's', targetElementId: 'missing' }] })
+        );
+        const structured = result.structuredContent as unknown as DryRunStructured;
+        expect(structured.validationResults[0].isValid).to.equal(false);
+        expect(structured.validationResults[0].reason).to.include('Target element not found');
+    });
+});

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

@@ -0,0 +1,205 @@
+/********************************************************************************
+ * 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 { ChangeRoutingPointsOperation, CreateEdgeOperation, DiagramConfiguration, EdgeCreationChecker } from '@eclipse-glsp/server';
+import { inject, injectable, optional } from 'inversify';
+import * as z from 'zod/v4';
+import {
+    ElementIdentity,
+    ElementIdentitySchema,
+    McpDiagramScopedInputSchema,
+    McpToolResult,
+    OperationMcpDiagramToolHandler,
+    position
+} from '../../server';
+import { formatNoticeList } from '../../util';
+
+/** Single edge-creation entry. Strict so an LLM-typoed field surfaces as a validation error instead of being silently dropped. */
+export const CreateEdgeSpecSchema = z.strictObject({
+    elementTypeId: z.string().describe('Edge type ID (e.g., `edge`, `transition`). Use the `element-types` tool to discover valid IDs.'),
+    sourceElementId: z.string().describe('ID of the source element (must exist in the diagram)'),
+    targetElementId: z.string().describe('ID of the target element (must exist in the diagram)'),
+    routingPoints: z.array(position).optional().describe('Optional array of routing point coordinates that allow for a complex edge path.'),
+    // `args` stays open (`record(...)`) — adopter-specific extension surface for per-edge-type creation hints.
+    args: z.record(z.string(), z.any()).optional().describe('Additional type-specific arguments for edge creation (varies by edge type)')
+});
+
+export const CreateEdgesInputSchema = McpDiagramScopedInputSchema.extend({
+    edges: z.array(CreateEdgeSpecSchema).min(1).describe('Array of edges to create. Must include at least one edge.'),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe(
+            'When true, validate each edge against the type-hint rules without creating anything; returns per-edge `validationResults`.'
+        )
+});
+export type CreateEdgesInput = z.infer<typeof CreateEdgesInputSchema>;
+
+export const CreateEdgesValidationResultSchema = z.object({
+    edgeType: z.string(),
+    sourceElementId: z.string(),
+    targetElementId: z.string(),
+    isValid: z.boolean(),
+    reason: z.string().optional().describe('Brief reason explaining the verdict (always present when `isValid: false`).')
+});
+
+export const CreateEdgesOutputSchema = z.object({
+    createdEdges: z.array(ElementIdentitySchema).describe('Identity of each edge successfully created. Empty in `dryRun` mode.'),
+    errors: z.array(z.string()).describe('Per-input failure messages; absent or empty when every input succeeded.'),
+    validationResults: z
+        .array(CreateEdgesValidationResultSchema)
+        .optional()
+        .describe('Per-input validation results. Present only in `dryRun` mode.')
+});
+
+type EdgeInput = CreateEdgesInput['edges'][number];
+type ValidationResult = z.infer<typeof CreateEdgesValidationResultSchema>;
+
+@injectable()
+export class CreateEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<CreateEdgesInput> {
+    static readonly NAME = 'create-edges';
+    readonly name = CreateEdgesMcpToolHandler.NAME;
+    override readonly title = 'Create Diagram Edges';
+    readonly description =
+        'Create one or multiple new edges connecting two elements in the diagram. ' +
+        'Set `dryRun: true` to validate proposed edges (per the diagram-type type-hint rules) ' +
+        'without creating anything; the result then carries per-edge `validationResults`. ' +
+        'Without `dryRun`, this operation modifies the diagram state and requires user approval. ' +
+        'Use the `element-types` tool to discover valid edge type IDs.';
+    readonly inputSchema = CreateEdgesInputSchema;
+    override readonly outputSchema = CreateEdgesOutputSchema;
+
+    @inject(DiagramConfiguration) protected diagramConfiguration: DiagramConfiguration;
+    @inject(EdgeCreationChecker) @optional() protected edgeCreationChecker?: EdgeCreationChecker;
+
+    protected async createResult({ edges, dryRun }: CreateEdgesInput): Promise<McpToolResult> {
+        if (dryRun) {
+            return this.runDryRun(edges);
+        }
+        return this.runCreate(edges);
+    }
+
+    protected runDryRun(edges: EdgeInput[]): McpToolResult {
+        const validationResults: ValidationResult[] = edges.map(edge => this.validateEdge(edge));
+        const validCount = validationResults.filter(result => result.isValid).length;
+        const summary =
+            `Dry run: validated ${edges.length} edge(s); ${validCount} would be accepted, ${edges.length - validCount} rejected.\n` +
+            validationResults
+                .map(
+                    result =>
+                        `- ${result.edgeType} ${result.sourceElementId} → ${result.targetElementId}: ` +
+                        `${result.isValid ? 'valid' : `invalid (${result.reason})`}`
+                )
+                .join('\n');
+        return this.success(summary, { createdEdges: [], errors: [], validationResults });
+    }
+
+    protected async runCreate(edges: EdgeInput[]): Promise<McpToolResult> {
+        let beforeIds = this.modelState.index.allIds();
+
+        const errors: string[] = [];
+        const createdEdges: ElementIdentity[] = [];
+        let dispatchedOperations = 0;
+        // Sequential — each iteration must isolate its own creation in the post-dispatch diff.
+        for (const edge of edges) {
+            const { elementTypeId, routingPoints, args } = edge;
+            const sourceElementId = this.aliasService.lookup(edge.sourceElementId);
+            const targetElementId = this.aliasService.lookup(edge.targetElementId);
+
+            const source = this.modelState.index.find(sourceElementId);
+            if (!source) {
+                errors.push(`Source element not found: ${edge.sourceElementId}`);
+                continue;
+            }
+            const target = this.modelState.index.find(targetElementId);
+            if (!target) {
+                errors.push(`Target element not found: ${edge.targetElementId}`);
+                continue;
+            }
+
+            const operation = CreateEdgeOperation.create({ elementTypeId, sourceElementId, targetElementId, 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(`Edge creation likely failed because no new element ID was found for input: ${JSON.stringify(edge)}`);
+                continue;
+            }
+
+            if (routingPoints) {
+                const routingPointsOperation = ChangeRoutingPointsOperation.create([
+                    { elementId: newElement.id, newRoutingPoints: routingPoints }
+                ]);
+                await this.actionDispatcher.dispatch(routingPointsOperation);
+                dispatchedOperations++;
+            }
+
+            createdEdges.push(this.describeResolvedElement(newElement));
+        }
+
+        const successListStr = createdEdges.map(({ id, elementTypeId }) => `- ${elementTypeId} (#${id})`).join('\n');
+        // Per-input errors are surfaced in `errors`; the call itself still succeeds — rolling back partial creates would require operation-level transactions.
+        return this.success(
+            `Successfully created ${createdEdges.length} edge(s) (in ${dispatchedOperations} commands):\n${successListStr}${formatNoticeList('errors', errors)}`,
+            { createdEdges, errors }
+        );
+    }
+
+    /** Mirrors `RequestCheckEdgeAction`: existence check, then dynamic-hint → checker; static or unknown edgeType → valid. */
+    protected validateEdge(edge: EdgeInput): ValidationResult {
+        const { elementTypeId } = edge;
+        const sourceRealId = this.aliasService.lookup(edge.sourceElementId);
+        const targetRealId = this.aliasService.lookup(edge.targetElementId);
+        const echo: Pick<ValidationResult, 'edgeType' | 'sourceElementId' | 'targetElementId'> = {
+            edgeType: elementTypeId,
+            sourceElementId: edge.sourceElementId,
+            targetElementId: edge.targetElementId
+        };
+
+        const source = this.modelState.index.find(sourceRealId);
+        if (!source) {
+            return { ...echo, isValid: false, reason: `Source element not found: ${edge.sourceElementId}` };
+        }
+        const target = this.modelState.index.find(targetRealId);
+        if (!target) {
+            return { ...echo, isValid: false, reason: `Target element not found: ${edge.targetElementId}` };
+        }
+
+        const hasDynamicHint = this.diagramConfiguration.edgeTypeHints.some(hint => hint.elementTypeId === elementTypeId && hint.dynamic);
+        if (!hasDynamicHint) {
+            return { ...echo, isValid: true, reason: 'no dynamic edge-type hint — static hints apply' };
+        }
+        if (!this.edgeCreationChecker) {
+            return {
+                ...echo,
+                isValid: false,
+                reason: `EdgeCreationChecker is not bound although edge type '${elementTypeId}' declares a dynamic hint.`
+            };
+        }
+        const isValid = this.edgeCreationChecker.isValidTarget(elementTypeId, source, target);
+        return { ...echo, isValid, ...(isValid ? {} : { reason: 'rejected by EdgeCreationChecker' }) };
+    }
+}