@eclipse-glsp/server-mcp 2.8.0-next.1 → 2.8.0-next.10

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

@@ -1,198 +0,0 @@
-/********************************************************************************
- * 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/common/tools/handlers/create-nodes-mcp-tool-handler.spec.ts

@@ -1,199 +0,0 @@
-/********************************************************************************
- * 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);
-    });
-});

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

@@ -1,212 +0,0 @@
-/********************************************************************************
- * 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, GLabel, GModelElement, Logger, ModelState, NullLogger } from '@eclipse-glsp/server';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import { McpModelSerializer } from '../../resources/services/mcp-model-serializer';
-import { McpElementsNotFoundError, McpToolResult } from '../../server/mcp-handler-shared';
-import { McpIdAliasService } from '../../server/mcp-id-alias-service';
-import { DefaultMcpLabelProvider, McpLabelProvider } from '../../server/mcp-label-provider';
-import { QueryElementsInput, QueryElementsMcpToolHandler } from './query-elements-mcp-tool-handler';
-
-function makeLabel(text: string): GLabel {
-    // Set the prototype so `child instanceof GLabel` checks in the handler return true.
-    return Object.assign(Object.create(GLabel.prototype), { id: 'label', type: 'label', text, children: [] }) as GLabel;
-}
-
-function makeElement(id: string, type: string, labelText?: string): GModelElement {
-    return {
-        id,
-        type,
-        children: labelText !== undefined ? [makeLabel(labelText)] : []
-    } 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;
-}
-
-interface CapturingSerializer extends McpModelSerializer {
-    /** Element arrays the handler passed to {@link serializeStructuredArray}, in call order. */
-    capturedArrays: GModelElement[][];
-}
-
-function makeCapturingSerializer(): CapturingSerializer {
-    const capturedArrays: GModelElement[][] = [];
-    return {
-        capturedArrays,
-        serialize: () => 'serialized',
-        serializeStructured: () => ({}),
-        serializeArray: elements => elements.map(el => `- ${el.id} (${el.type})`).join('\n'),
-        serializeStructuredArray: elements => {
-            capturedArrays.push(elements);
-            return { elements: elements.map(el => ({ id: el.id, type: el.type })) };
-        }
-    };
-}
-
-function buildHandler(elements: GModelElement[], serializer: McpModelSerializer = makeCapturingSerializer()): QueryElementsMcpToolHandler {
-    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(McpModelSerializer).toConstantValue(serializer);
-            bind(McpLabelProvider).to(DefaultMcpLabelProvider);
-            bind(QueryElementsMcpToolHandler).toSelf();
-        })
-    );
-    return container.get(QueryElementsMcpToolHandler);
-}
-
-interface ListStructured {
-    mode: 'list';
-    matches: { id: string; type: string; label?: string }[];
-    truncated: boolean;
-}
-interface InspectStructured {
-    mode: 'inspect';
-    elements: { id: string; type: string }[];
-}
-
-function callCreateResult(handler: QueryElementsMcpToolHandler, params: QueryElementsInput): Promise<McpToolResult> {
-    return (handler as unknown as { createResult: (p: QueryElementsInput) => Promise<McpToolResult> }).createResult(params);
-}
-
-describe('QueryElementsMcpToolHandler', () => {
-    describe('list mode (no `elementIds`)', () => {
-        it('filters by `types` (only matching types are returned)', async () => {
-            const handler = buildHandler([
-                makeElement('n1', 'task:manual', 'Build'),
-                makeElement('n2', 'task:automated', 'Deploy'),
-                makeElement('e1', 'edge')
-            ]);
-
-            const result = await callCreateResult(handler, { sessionId: 's', types: ['task:manual'] });
-            const structured = result.structuredContent as unknown as ListStructured;
-            expect(structured.mode).to.equal('list');
-            expect(structured.matches).to.have.lengthOf(1);
-            expect(structured.matches[0].id).to.equal('n1');
-        });
-
-        it('matches `labelMatch` case-insensitively against direct GLabel children', async () => {
-            const handler = buildHandler([
-                makeElement('n1', 'task', 'Build artifact'),
-                makeElement('n2', 'task', 'Deploy artifact'),
-                makeElement('n3', 'task', 'Validate spec')
-            ]);
-
-            const result = await callCreateResult(handler, { sessionId: 's', labelMatch: 'ARTIFACT' });
-            const ids = (result.structuredContent as unknown as ListStructured).matches.map(m => m.id);
-            expect(ids).to.have.members(['n1', 'n2']);
-        });
-
-        it('combines `types` and `labelMatch` as AND', async () => {
-            const handler = buildHandler([
-                makeElement('n1', 'task:manual', 'Build artifact'),
-                makeElement('n2', 'task:automated', 'Build artifact')
-            ]);
-
-            const result = await callCreateResult(handler, {
-                sessionId: 's',
-                types: ['task:manual'],
-                labelMatch: 'build'
-            });
-            const matches = (result.structuredContent as unknown as ListStructured).matches;
-            expect(matches).to.have.lengthOf(1);
-            expect(matches[0].id).to.equal('n1');
-        });
-
-        it('caps results at `limit` and reports `truncated: true`', async () => {
-            const elements = Array.from({ length: 10 }, (_, i) => makeElement(`n${i}`, 'task'));
-            const handler = buildHandler(elements);
-
-            const result = await callCreateResult(handler, { sessionId: 's', limit: 3 });
-            const structured = result.structuredContent as unknown as ListStructured;
-            expect(structured.matches).to.have.lengthOf(3);
-            expect(structured.truncated).to.equal(true);
-        });
-
-        it('surfaces a no-match message and empty matches when nothing matches', async () => {
-            const handler = buildHandler([makeElement('n1', 'task', 'foo')]);
-
-            const result = await callCreateResult(handler, { sessionId: 's', types: ['nonexistent'] });
-            const text = (result.content[0] as { text: string }).text;
-            expect(text).to.include('No elements matched');
-            expect((result.structuredContent as unknown as ListStructured).matches).to.deep.equal([]);
-        });
-    });
-
-    describe('inspect mode (with `elementIds`)', () => {
-        it('resolves the requested ids and forwards the matching elements to the serializer', async () => {
-            const elements = [makeElement('n1', 'task:manual', 'Build'), makeElement('n2', 'task:automated', 'Deploy')];
-            const serializer = makeCapturingSerializer();
-            const handler = buildHandler(elements, serializer);
-
-            const result = await callCreateResult(handler, { sessionId: 's', elementIds: ['n1', 'n2'] });
-
-            // The handler delegated rendering to the injected serializer with the exact
-            // GModelElement instances looked up from the model index — not just the ids. Inspect
-            // mode also probes per-element to detect container expansion before rendering, so the
-            // final array call is what produces the structuredContent — assert on that one.
-            expect(serializer.capturedArrays.length).to.be.greaterThan(0);
-            const finalCall = serializer.capturedArrays[serializer.capturedArrays.length - 1];
-            expect(finalCall).to.deep.equal(elements);
-
-            const structured = result.structuredContent as unknown as InspectStructured;
-            expect(structured.mode).to.equal('inspect');
-        });
-
-        it('throws McpElementsNotFoundError when an id is missing from the model', async () => {
-            const handler = buildHandler([makeElement('n1', 'task')]);
-
-            try {
-                await callCreateResult(handler, { sessionId: 's', elementIds: ['n1', 'unknown'] });
-                expect.fail('expected McpElementsNotFoundError');
-            } catch (err) {
-                expect(err).to.be.instanceOf(McpElementsNotFoundError);
-            }
-        });
-
-        it('ignores `types` / `labelMatch` / `limit` when `elementIds` is set', async () => {
-            const handler = buildHandler([makeElement('n1', 'task:manual'), makeElement('n2', 'task:automated')]);
-
-            const result = await callCreateResult(handler, {
-                sessionId: 's',
-                elementIds: ['n1'],
-                types: ['task:automated'], // would exclude n1 in list mode
-                labelMatch: 'nope',
-                limit: 0 // intentionally would fail validation in list mode
-            });
-            const structured = result.structuredContent as unknown as InspectStructured;
-            expect(structured.mode).to.equal('inspect');
-            expect(structured.elements.map(e => e.id)).to.deep.equal(['n1']);
-        });
-    });
-});