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

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

@@ -0,0 +1,198 @@
+/********************************************************************************
+ * 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 { McpToolResult } from '../../server/mcp-handler-shared';
+import { McpIdAliasService } from '../../server/mcp-id-alias-service';
+import { DefaultMcpLabelProvider, McpLabelProvider } from '../../server/mcp-label-provider';
+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,200 @@
+/********************************************************************************
+ * 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 { McpToolResult } from '../../server/mcp-handler-shared';
+import { ElementIdentity, ElementIdentitySchema, McpDiagramScopedInputSchema, position } from '../../server/mcp-input-schemas';
+import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
+import { formatNoticeList } from '../../util/mcp-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' }) };
+    }
+}

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

@@ -0,0 +1,199 @@
+/********************************************************************************
+ * 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 { McpToolResult } from '../../server/mcp-handler-shared';
+import { McpIdAliasService } from '../../server/mcp-id-alias-service';
+import { McpLabelProvider } from '../../server/mcp-label-provider';
+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);
+    });
+});