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

package/src/common/server/mcp-logger.spec.ts

@@ -1,235 +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 { Logger, NullLogger } from '@eclipse-glsp/server';
-import { ServerNotification } from '@modelcontextprotocol/sdk/types.js';
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import { DefaultMcpLogLevelRegistry, McpLogLevelRegistry } from './mcp-log-level-registry';
-import { McpLogger } from './mcp-logger';
-import { NodeMcpRequestContext } from '../../node/server/node-mcp-request-context';
-import { McpRequestContext, McpRequestExtra } from './mcp-request-context';
-
-interface RecordedLog {
-    level: string;
-    message: string;
-}
-
-class RecordingLogger extends NullLogger {
-    readonly entries: RecordedLog[] = [];
-    override info(message: string): void {
-        this.entries.push({ level: 'info', message });
-    }
-    override warn(message: string): void {
-        this.entries.push({ level: 'warn', message });
-    }
-    override error(message: string): void {
-        this.entries.push({ level: 'error', message });
-    }
-    override debug(message: string): void {
-        this.entries.push({ level: 'debug', message });
-    }
-}
-
-function buildLogger(): {
-    logger: McpLogger;
-    glspLogger: RecordingLogger;
-    levelRegistry: DefaultMcpLogLevelRegistry;
-    requestContext: McpRequestContext;
-} {
-    const container = new Container();
-    const glspLogger = new RecordingLogger();
-    const levelRegistry = new DefaultMcpLogLevelRegistry();
-    const requestContext = new NodeMcpRequestContext();
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(glspLogger);
-            bind(McpLogLevelRegistry).toConstantValue(levelRegistry);
-            bind(McpRequestContext).toConstantValue(requestContext);
-            bind(McpLogger).toSelf().inSingletonScope();
-        })
-    );
-    return { logger: container.get(McpLogger), glspLogger, levelRegistry, requestContext };
-}
-
-/**
- * Build a stub `RequestHandlerExtra` with a recording `sendNotification`. Only `sendNotification`
- * is exercised by `McpLogger`; the remaining fields are never read here, so we cast rather
- * than fabricate the full SDK shape.
- */
-function buildExtra(sessionId?: string): { extra: McpRequestExtra; sent: ServerNotification[] } {
-    const sent: ServerNotification[] = [];
-    const extra = {
-        sessionId,
-        sendNotification: async (n: ServerNotification) => {
-            sent.push(n);
-        }
-    } as unknown as McpRequestExtra;
-    return { extra, sent };
-}
-
-describe('McpLogger', () => {
-    describe('outside a request context (no MCP client to deliver to)', () => {
-        it('routes info/warn/error/debug to the GLSP Logger only', () => {
-            const { logger, glspLogger } = buildLogger();
-
-            logger.info('hello');
-            logger.warn('careful');
-            logger.error('boom');
-            logger.debug('trace');
-
-            expect(glspLogger.entries).to.deep.equal([
-                { level: 'info', message: 'hello' },
-                { level: 'warn', message: 'careful' },
-                { level: 'error', message: 'boom' },
-                { level: 'debug', message: 'trace' }
-            ]);
-        });
-    });
-
-    describe('inside an requestContext.run frame', () => {
-        it('emits notifications/message to the bound MCP client AND the GLSP Logger', async () => {
-            const { logger, glspLogger, requestContext } = buildLogger();
-            const { extra, sent } = buildExtra();
-
-            await requestContext.run(extra, async () => {
-                logger.info('one');
-                logger.warn('two');
-                logger.error('three');
-                logger.debug('four');
-                // Allow the fire-and-forget `.catch` chain in McpLogger.notify to settle.
-                await new Promise(resolve => setImmediate(resolve));
-            });
-
-            expect(glspLogger.entries.map(e => e.message)).to.deep.equal(['one', 'two', 'three', 'four']);
-            expect(
-                sent.map(n => ({
-                    method: n.method,
-                    level: (n.params as { level: string }).level,
-                    data: (n.params as { data: string }).data
-                }))
-            ).to.deep.equal([
-                { method: 'notifications/message', level: 'info', data: 'one' },
-                { method: 'notifications/message', level: 'warning', data: 'two' }, // GLSP warn → MCP warning
-                { method: 'notifications/message', level: 'error', data: 'three' },
-                { method: 'notifications/message', level: 'debug', data: 'four' }
-            ]);
-        });
-
-        it('swallows transport failures so a broken MCP send never breaks the producing tool', async () => {
-            const { logger, glspLogger, requestContext } = buildLogger();
-            const failingExtra = {
-                sendNotification: async () => {
-                    throw new Error('transport closed');
-                }
-            } as unknown as McpRequestExtra;
-
-            await requestContext.run(failingExtra, async () => {
-                expect(() => logger.error('still works')).to.not.throw();
-                await new Promise(resolve => setImmediate(resolve));
-            });
-
-            // Server-side log still fired.
-            expect(glspLogger.entries).to.deep.equal([{ level: 'error', message: 'still works' }]);
-        });
-    });
-
-    describe('concurrent request contexts', () => {
-        it('keeps each request frame isolated via AsyncLocalStorage', async () => {
-            const { logger, requestContext } = buildLogger();
-            const { extra: extraA, sent: sentA } = buildExtra();
-            const { extra: extraB, sent: sentB } = buildExtra();
-
-            await Promise.all([
-                requestContext.run(extraA, async () => {
-                    logger.info('A');
-                    await new Promise(resolve => setImmediate(resolve));
-                    logger.info('A-after-yield');
-                }),
-                requestContext.run(extraB, async () => {
-                    logger.info('B');
-                    await new Promise(resolve => setImmediate(resolve));
-                    logger.info('B-after-yield');
-                })
-            ]);
-
-            expect(sentA.map(n => (n.params as { data: string }).data)).to.deep.equal(['A', 'A-after-yield']);
-            expect(sentB.map(n => (n.params as { data: string }).data)).to.deep.equal(['B', 'B-after-yield']);
-        });
-    });
-
-    describe('logging/setLevel threshold gate (G4)', () => {
-        it('drops messages below the per-session threshold; the GLSP-side log still fires', async () => {
-            const { logger, glspLogger, levelRegistry, requestContext } = buildLogger();
-            const { extra, sent } = buildExtra('session-X');
-            // Client opted down to "warning" — info and debug must be dropped on the MCP side.
-            levelRegistry.setLevel('session-X', 'warning');
-
-            await requestContext.run(extra, async () => {
-                logger.info('chatty');
-                logger.debug('verbose');
-                logger.warn('important');
-                logger.error('critical');
-                await new Promise(resolve => setImmediate(resolve));
-            });
-
-            // GLSP-side log path is independent of the MCP threshold — keeps adopter logs intact.
-            expect(glspLogger.entries.map(entry => entry.message)).to.deep.equal(['chatty', 'verbose', 'important', 'critical']);
-            // MCP side: only warn + error survive.
-            expect(sent.map(n => (n.params as { level: string }).level)).to.deep.equal(['warning', 'error']);
-        });
-
-        it('isolates thresholds across sessions (different setLevel per session id)', async () => {
-            const { logger, levelRegistry, requestContext } = buildLogger();
-            const { extra: extraA, sent: sentA } = buildExtra('session-A');
-            const { extra: extraB, sent: sentB } = buildExtra('session-B');
-            levelRegistry.setLevel('session-A', 'error');
-            levelRegistry.setLevel('session-B', 'debug');
-
-            await Promise.all([
-                requestContext.run(extraA, async () => {
-                    logger.info('A-info');
-                    logger.error('A-error');
-                    await new Promise(resolve => setImmediate(resolve));
-                }),
-                requestContext.run(extraB, async () => {
-                    logger.info('B-info');
-                    logger.error('B-error');
-                    await new Promise(resolve => setImmediate(resolve));
-                })
-            ]);
-
-            expect(sentA.map(n => (n.params as { data: string }).data)).to.deep.equal(['A-error']);
-            expect(sentB.map(n => (n.params as { data: string }).data).sort()).to.deep.equal(['B-error', 'B-info']);
-        });
-
-        it('default threshold (no setLevel sent) lets every level through (preserves prior behavior)', async () => {
-            const { logger, requestContext } = buildLogger();
-            const { extra, sent } = buildExtra('session-default');
-            // No setLevel call → default threshold = 'debug' → everything emitted.
-
-            await requestContext.run(extra, async () => {
-                logger.debug('d');
-                logger.info('i');
-                logger.warn('w');
-                logger.error('e');
-                await new Promise(resolve => setImmediate(resolve));
-            });
-
-            expect(sent.map(n => (n.params as { level: string }).level)).to.deep.equal(['debug', 'info', 'warning', 'error']);
-        });
-    });
-});

package/src/common/server/mcp-progress-reporter.spec.ts

@@ -1,103 +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 { ServerNotification } from '@modelcontextprotocol/sdk/types.js';
-import { expect } from 'chai';
-import { McpProgressReporter } from './mcp-progress-reporter';
-import { Container } from 'inversify';
-import { NodeMcpRequestContext } from '../../node/server/node-mcp-request-context';
-import { McpRequestContext, McpRequestExtra } from './mcp-request-context';
-
-function buildExtra(progressToken?: string | number): { extra: McpRequestExtra; sent: ServerNotification[] } {
-    const sent: ServerNotification[] = [];
-    const extra = {
-        sendNotification: async (n: ServerNotification) => {
-            sent.push(n);
-        },
-        _meta: progressToken === undefined ? undefined : { progressToken }
-    } as unknown as McpRequestExtra;
-    return { extra, sent };
-}
-
-function buildReporter(): { reporter: McpProgressReporter; requestContext: McpRequestContext } {
-    const container = new Container();
-    const requestContext = new NodeMcpRequestContext();
-    container.bind(McpRequestContext).toConstantValue(requestContext);
-    container.bind(McpProgressReporter).toSelf().inSingletonScope();
-    return { reporter: container.get(McpProgressReporter), requestContext };
-}
-
-describe('McpProgressReporter', () => {
-    it('no-ops inside a request that has no progressToken (client did not opt in)', async () => {
-        const { reporter, requestContext } = buildReporter();
-        const { extra, sent } = buildExtra(undefined);
-
-        await requestContext.run(extra, async () => {
-            await reporter.emit({ progress: 0, message: 'starting' });
-        });
-
-        expect(sent).to.have.lengthOf(0);
-    });
-
-    it('emits notifications/progress when the request carries a progressToken', async () => {
-        const { reporter, requestContext } = buildReporter();
-        const { extra, sent } = buildExtra('tok-42');
-
-        await requestContext.run(extra, async () => {
-            await reporter.emit({ progress: 0, message: 'starting' });
-            await reporter.emit({ progress: 1, total: 3, message: 'step 1/3' });
-        });
-
-        expect(sent).to.have.lengthOf(2);
-        expect(sent[0]).to.deep.equal({
-            method: 'notifications/progress',
-            params: { progressToken: 'tok-42', progress: 0, message: 'starting' }
-        });
-        expect(sent[1]).to.deep.equal({
-            method: 'notifications/progress',
-            params: { progressToken: 'tok-42', progress: 1, total: 3, message: 'step 1/3' }
-        });
-    });
-
-    it('accepts numeric progress tokens', async () => {
-        const { reporter, requestContext } = buildReporter();
-        const { extra, sent } = buildExtra(7);
-
-        await requestContext.run(extra, async () => {
-            await reporter.emit({ progress: 0 });
-        });
-
-        expect(sent).to.have.lengthOf(1);
-        expect(sent[0].params).to.deep.equal({ progressToken: 7, progress: 0 });
-    });
-
-    it('swallows transport failures so a broken send never breaks the producing tool', async () => {
-        const { reporter, requestContext } = buildReporter();
-        const failingExtra = {
-            sendNotification: async () => {
-                throw new Error('transport closed');
-            },
-            _meta: { progressToken: 'tok-1' }
-        } as unknown as McpRequestExtra;
-
-        await requestContext.run(failingExtra, async () => {
-            // Must complete without throwing. If we re-threw, every PNG export would hard-fail
-            // when the client's SSE stream blipped — the opposite of progress reporting being
-            // a UX nicety.
-            await reporter.emit({ progress: 0, message: 'starting' });
-        });
-    });
-});

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

@@ -1,182 +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 { expect } from 'chai';
-import * as z from 'zod/v4';
-import { McpToolResult } from './mcp-handler-shared';
-import { CreateEdgesMcpToolHandler, CreateEdgesOutputSchema } from '../tools/handlers/create-edges-mcp-tool-handler';
-import { CreateNodesMcpToolHandler, CreateNodesOutputSchema } from '../tools/handlers/create-nodes-mcp-tool-handler';
-import { DeleteElementsMcpToolHandler, DeleteElementsOutputSchema } from '../tools/handlers/delete-elements-mcp-tool-handler';
-import { GetSelectionMcpToolHandler, GetSelectionOutputSchema } from '../tools/handlers/get-selection-mcp-tool-handler';
-import { LayoutMcpToolHandler, LayoutOutputSchema } from '../tools/handlers/layout-mcp-tool-handler';
-import { ModifyEdgesMcpToolHandler, ModifyEdgesOutputSchema } from '../tools/handlers/modify-edges-mcp-tool-handler';
-import { ModifyNodesMcpToolHandler, ModifyNodesOutputSchema } from '../tools/handlers/modify-nodes-mcp-tool-handler';
-import { QueryElementsMcpToolHandler, QueryElementsOutputSchema } from '../tools/handlers/query-elements-mcp-tool-handler';
-import { RedoMcpToolHandler, RedoOutputSchema } from '../tools/handlers/redo-mcp-tool-handler';
-import { SaveModelMcpToolHandler, SaveModelOutputSchema } from '../tools/handlers/save-model-mcp-tool-handler';
-import { SetViewMcpToolHandler, SetViewOutputSchema } from '../tools/handlers/set-view-mcp-tool-handler';
-import { UndoMcpToolHandler, UndoOutputSchema } from '../tools/handlers/undo-mcp-tool-handler';
-import { ValidateDiagramMcpToolHandler, ValidateDiagramOutputSchema } from '../tools/handlers/validate-diagram-mcp-tool-handler';
-import { AbstractMcpToolHandler } from './mcp-tool-handler';
-
-// ─── Framework: BaseMcpToolHandler.success(...) and toRegistrationConfig() ────────────────────
-
-class WithoutOutputSchemaHandler extends AbstractMcpToolHandler {
-    readonly name = 'no-schema';
-    readonly description = 'no-schema';
-    readonly inputSchema = z.object({});
-
-    protected createResult(): McpToolResult {
-        return this.success('plain');
-    }
-
-    /** Test exposure of the protected helper. `BaseMcpToolHandler` doesn't read `logger` here. */
-    public testSuccess(message: string, structured?: Record<string, unknown>): McpToolResult {
-        return this.success(message, structured);
-    }
-}
-
-class WithOutputSchemaHandler extends AbstractMcpToolHandler {
-    readonly name = 'with-schema';
-    readonly description = 'with-schema';
-    readonly inputSchema = z.object({});
-    override readonly outputSchema = z.object({ ok: z.boolean() });
-
-    protected createResult(): McpToolResult {
-        return this.success('with', { ok: true });
-    }
-}
-
-describe('Dual-emit framework', () => {
-    it('success(message) without structured payload omits structuredContent', () => {
-        const result = new WithoutOutputSchemaHandler().testSuccess('hi');
-        expect(result.content).to.deep.equal([{ type: 'text', text: 'hi' }]);
-        expect(result.structuredContent).to.equal(undefined);
-        expect(result.isError).to.equal(false);
-    });
-
-    it('success(message, structured) emits structuredContent', () => {
-        const result = new WithoutOutputSchemaHandler().testSuccess('hi', { count: 3, ids: ['a'] });
-        expect(result.content).to.deep.equal([{ type: 'text', text: 'hi' }]);
-        expect(result.structuredContent).to.deep.equal({ count: 3, ids: ['a'] });
-    });
-
-    it('toRegistrationConfig() omits outputSchema when not declared', () => {
-        const config = new WithoutOutputSchemaHandler().toRegistrationConfig();
-        expect(config.outputSchema).to.equal(undefined);
-    });
-
-    it('toRegistrationConfig() forwards outputSchema when declared', () => {
-        const config = new WithOutputSchemaHandler().toRegistrationConfig();
-        expect(config.outputSchema).to.not.equal(undefined);
-        // The SDK accepts a full `ZodObject` (or its raw shape); we pass the wrapped object so
-        // strict-mode rejection of unknown keys can extend uniformly to outputs.
-        expect(Object.keys(config.outputSchema!.shape)).to.deep.equal(['ok']);
-    });
-});
-
-// ─── Per-handler schema matrix ────────────────────────────────────────────────────────────────
-
-/**
- * Each entry binds a handler constructor to its declared `OutputSchema` + a representative
- * structured payload. The expectations:
- *   - Constructor's `outputSchema` field matches the exported schema (same reference).
- *   - The schema accepts the representative payload (zod parse passes).
- */
-const matrix: Array<{
-    name: string;
-    Constructor: new () => { outputSchema?: unknown };
-    schema: z.ZodObject;
-    sample: Record<string, unknown>;
-}> = [
-    {
-        name: 'create-nodes',
-        Constructor: CreateNodesMcpToolHandler,
-        schema: CreateNodesOutputSchema,
-        sample: { createdNodes: [{ id: 'n1', elementTypeId: 'node:foo' }], dispatchedCommands: 1, errors: [], warnings: [] }
-    },
-    {
-        name: 'create-edges',
-        Constructor: CreateEdgesMcpToolHandler,
-        schema: CreateEdgesOutputSchema,
-        sample: { createdEdges: [{ id: 'e1', elementTypeId: 'edge' }], dispatchedCommands: 1, errors: [] }
-    },
-    {
-        name: 'modify-nodes',
-        Constructor: ModifyNodesMcpToolHandler,
-        schema: ModifyNodesOutputSchema,
-        sample: { modifiedNodes: [{ id: 'n1', elementTypeId: 'node:foo' }], dispatchedCommands: 1, warnings: [] }
-    },
-    {
-        name: 'modify-edges',
-        Constructor: ModifyEdgesMcpToolHandler,
-        schema: ModifyEdgesOutputSchema,
-        sample: { modifiedEdges: [{ id: 'e1', elementTypeId: 'edge' }], dispatchedCommands: 1, errors: [] }
-    },
-    {
-        name: 'delete-elements',
-        Constructor: DeleteElementsMcpToolHandler,
-        schema: DeleteElementsOutputSchema,
-        sample: { deletedElements: [{ id: 'n1', elementTypeId: 'node:foo' }], deletedCount: 3, dispatchedCommands: 1 }
-    },
-    { name: 'undo', Constructor: UndoMcpToolHandler, schema: UndoOutputSchema, sample: { commandsUndone: 2 } },
-    { name: 'redo', Constructor: RedoMcpToolHandler, schema: RedoOutputSchema, sample: { commandsRedone: 2 } },
-    { name: 'layout', Constructor: LayoutMcpToolHandler, schema: LayoutOutputSchema, sample: { applied: true, dispatchedCommands: 1 } },
-    {
-        name: 'validate-diagram',
-        Constructor: ValidateDiagramMcpToolHandler,
-        schema: ValidateDiagramOutputSchema,
-        sample: { markers: [{ kind: 'error', label: 'bad', description: 'bad bad', elementId: 'n1' }] }
-    },
-    {
-        name: 'get-selection',
-        Constructor: GetSelectionMcpToolHandler,
-        schema: GetSelectionOutputSchema,
-        sample: { selectedElementIds: ['n1', 'n2'] }
-    },
-    {
-        name: 'query-elements',
-        Constructor: QueryElementsMcpToolHandler,
-        schema: QueryElementsOutputSchema,
-        sample: { mode: 'inspect', elements: [{ id: 'n1', type: 'node:foo', position: { x: 0, y: 0 } }] }
-    },
-    {
-        name: 'save-model',
-        Constructor: SaveModelMcpToolHandler,
-        schema: SaveModelOutputSchema,
-        sample: { saved: true, fileUri: 'file:///a' }
-    },
-    {
-        name: 'set-view',
-        Constructor: SetViewMcpToolHandler,
-        schema: SetViewOutputSchema,
-        sample: { action: 'fit-to-screen', targetIds: ['n1'] }
-    }
-];
-
-describe('Tool output schemas · per-handler matrix', () => {
-    matrix.forEach(({ name, Constructor, schema, sample }) => {
-        describe(name, () => {
-            it('declares outputSchema referencing the exported schema constant', () => {
-                expect(new Constructor().outputSchema).to.equal(schema);
-            });
-
-            it('schema accepts a representative structured payload', () => {
-                expect(() => schema.parse(sample)).to.not.throw();
-            });
-        });
-    });
-});

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

@@ -1,101 +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, 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 { 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));
-    });
-});