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

package/src/resources/services/mcp-model-serializer.ts

@@ -0,0 +1,211 @@
+/********************************************************************************
+ * 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 { GModelElement } from '@eclipse-glsp/graph';
+import { Dimension, GModelSerializer, Logger, Point } from '@eclipse-glsp/server';
+import { inject, injectable, postConstruct } from 'inversify';
+import { McpStructuredContent } from '../../server/mcp-handler-shared';
+import { McpIdAliasService } from '../../server/mcp-id-alias-service';
+import { objectArrayToMarkdownTable } from '../../util/markdown-util';
+
+export const McpModelSerializer = Symbol('McpModelSerializer');
+
+/** Loose JSON-object shape mirroring `GModelSerializer.createSchema` output — open-keyed because
+ * GModel attributes vary per element type. Reads must narrow before use. */
+export interface SerializedElement {
+    [key: string]: unknown;
+}
+
+/**
+ * Transforms a graphical model into a representation suitable for LLM consumption. Markdown and
+ * JSON are both reasonable formats; the default impl ({@link MarkdownMcpModelSerializer}) emits
+ * Markdown for {@link serialize}/{@link serializeArray} and an object payload for
+ * {@link serializeStructured} (the dual-emit `structuredContent` counterpart). Aliasing of element
+ * ids happens internally via the per-session {@link McpIdAliasService}.
+ *
+ * @experimental
+ */
+export interface McpModelSerializer {
+    /** Serializes a single element (and its descendants). */
+    serialize(element: GModelElement): string;
+
+    /** Serializes an array of elements; duplicates introduced by hierarchy are removed. */
+    serializeArray(elements: GModelElement[]): string;
+
+    /**
+     * Structured-content counterpart of {@link serialize} for dual-emit
+     * (`CallToolResult.structuredContent`). The shape is intentionally open: `{ elements: [...] }`
+     * with each entry carrying `id` + `type` + adopter-specific attrs (passthrough).
+     */
+    serializeStructured(element: GModelElement): McpStructuredContent;
+
+    /** Structured-content counterpart of {@link serializeArray}. */
+    serializeStructuredArray(elements: GModelElement[]): McpStructuredContent;
+}
+
+/**
+ * Default {@link McpModelSerializer} — emits Markdown with one H1 section per element type
+ * followed by a table of all elements of that type. Flattens the GModel tree, drops keys with
+ * no LLM value (`cssClasses`, `revision`, `layout`, etc., see {@link keysToRemove}), truncates
+ * position+size to integers and derives a `bounds` rectangle so the LLM doesn't redo arithmetic.
+ *
+ * Generic: no control over element order or per-type attribute order, since no specific GLSP
+ * adopter is known. Adopters override (see workflow's `WorkflowMcpModelSerializer`) when
+ * semantic ordering matters.
+ */
+@injectable()
+export class MarkdownMcpModelSerializer implements McpModelSerializer {
+    @inject(GModelSerializer) protected gModelSerializer: GModelSerializer;
+    @inject(McpIdAliasService) protected aliasService: McpIdAliasService;
+    @inject(Logger) protected logger: Logger;
+
+    protected keysToRemove: string[] = [
+        'cssClasses',
+        'revision',
+        'layout',
+        'args',
+        'layoutOptions',
+        'alignment',
+        'children',
+        'routingPoints',
+        'resizeLocations',
+        'parent'
+    ];
+
+    /** Warn once per binding when the bare default is used — subclasses suppress via the constructor check. */
+    @postConstruct()
+    protected warnIfGenericDefault(): void {
+        if (this.constructor === MarkdownMcpModelSerializer) {
+            this.logger.warn(
+                'Using generic MarkdownMcpModelSerializer; bind a diagram-specific subclass via ' +
+                    'DefaultMcpDiagramModule.bindModelSerializer() for richer LLM output.'
+            );
+        }
+    }
+
+    serialize(element: GModelElement): string {
+        return this.serializeArray([element]);
+    }
+
+    serializeArray(elements: GModelElement[]): string {
+        return Object.entries(this.buildAliasedTypeBuckets(elements))
+            .filter(([, bucket]) => bucket.length > 0)
+            .flatMap(([type, bucket]) => [`# ${type}`, objectArrayToMarkdownTable(bucket)])
+            .join('\n');
+    }
+
+    serializeStructured(element: GModelElement): McpStructuredContent {
+        return this.serializeStructuredArray([element]);
+    }
+
+    serializeStructuredArray(elements: GModelElement[]): McpStructuredContent {
+        return {
+            elements: Object.values(this.buildAliasedTypeBuckets(elements))
+                .filter(bucket => bucket.length > 0)
+                .flat()
+        };
+    }
+
+    /** Common pipeline: prepare, dedupe by id, group by type, alias ids — used by both renders. */
+    protected buildAliasedTypeBuckets(elements: GModelElement[]): Record<string, SerializedElement[]> {
+        const elementsByTypeArray = elements.map(element => this.prepareElement(element));
+        const result: Record<string, SerializedElement[]> = {};
+        const allKeys = new Set(elementsByTypeArray.flatMap(obj => Object.keys(obj)));
+        allKeys.forEach(key => {
+            const combined = elementsByTypeArray.flatMap(obj => obj[key] ?? []);
+            result[key] = Array.from(new Map(combined.map(item => [item.id, item])).values()).map(item => this.applyAlias(item));
+        });
+        return result;
+    }
+
+    protected applyAlias(element: SerializedElement): SerializedElement {
+        for (const field of ['id', 'sourceId', 'targetId', 'parentId'] as const) {
+            const value = element[field];
+            if (typeof value === 'string') {
+                element[field] = this.aliasService.alias(value);
+            }
+        }
+        return element;
+    }
+
+    protected prepareElement(element: GModelElement): Record<string, SerializedElement[]> {
+        const schema = this.gModelSerializer.createSchema(element) as unknown as SerializedElement;
+        const elements = this.flattenStructure(schema, element.parent?.id);
+
+        const result: Record<string, SerializedElement[]> = {};
+        elements.forEach(elem => {
+            this.removeKeys(elem);
+            this.combinePositionAndSize(elem);
+            const type = typeof elem.type === 'string' ? elem.type : 'unknown';
+            (result[type] ??= []).push(elem);
+        });
+
+        return result;
+    }
+
+    protected flattenStructure(element: SerializedElement, parentId?: string): SerializedElement[] {
+        const newElement: SerializedElement = { ...element };
+        const result: SerializedElement[] = [newElement];
+        const children = newElement.children;
+        if (Array.isArray(children)) {
+            const ownId = typeof newElement.id === 'string' ? newElement.id : undefined;
+            children.forEach(child =>
+                this.flattenStructure(child as SerializedElement, ownId).forEach(descendant => result.push(descendant))
+            );
+        }
+        newElement.parentId = parentId;
+        return result;
+    }
+
+    protected removeKeys(element: SerializedElement): void {
+        for (const key of Object.keys(element)) {
+            if (this.keysToRemove.includes(key)) {
+                delete element[key];
+            }
+        }
+    }
+
+    protected combinePositionAndSize(element: SerializedElement): void {
+        const position = element.position;
+        if (!Point.is(position)) {
+            return;
+        }
+        const x = Math.trunc(position.x);
+        const y = Math.trunc(position.y);
+        element.position = { x, y };
+
+        // Omit `size` and `bounds` when an element has no explicit geometry yet (e.g., a freshly
+        // created node whose `.size()` has not been applied). Emitting `{width: 0, height: 0}`
+        // would mislead an LLM consumer into "fixing" placeholder bounds. Visual rendering on
+        // the GLSP/sprotty client is unaffected — those nodes are laid out via CSS regardless.
+        const size = element.size;
+        if (!Dimension.is(size) || (Math.trunc(size.width) === 0 && Math.trunc(size.height) === 0)) {
+            delete element.size;
+            delete element.bounds;
+            return;
+        }
+
+        const width = Math.trunc(size.width);
+        const height = Math.trunc(size.height);
+        element.size = { width, height };
+        element.bounds = {
+            left: x,
+            right: x + width,
+            top: y,
+            bottom: y + height
+        };
+    }
+}

package/src/server/glsp-mcp-server.spec.ts

@@ -0,0 +1,73 @@
+/********************************************************************************
+ * 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 { NullLogger } from '@eclipse-glsp/server';
+import { McpServer, RegisteredResource } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import * as z from 'zod/v4';
+import { DefaultGLSPMcpServer } from './glsp-mcp-server';
+
+describe('DefaultGLSPMcpServer', () => {
+    function makeServer(): { wrapper: DefaultGLSPMcpServer; sdk: McpServer } {
+        const sdk = new McpServer({ name: 'test', version: '1.0.0' }, { capabilities: {} });
+        const wrapper = new DefaultGLSPMcpServer(sdk, { dataMode: 'tools' }, new NullLogger());
+        return { wrapper, sdk };
+    }
+
+    it('tracks every registerTool call so listTools returns the registered set', () => {
+        const { wrapper } = makeServer();
+        wrapper.registerTool('alpha', { description: 'first', inputSchema: { x: z.string() } }, async () => ({ content: [] }));
+        wrapper.registerTool('beta', { description: 'second' }, async () => ({ content: [] }));
+
+        const names = wrapper.listTools().map(tool => tool.description);
+        expect(names).to.have.members(['first', 'second']);
+        expect(wrapper.listTools()).to.have.lengthOf(2);
+    });
+
+    it('tracks registerResource (static URI) and listResources reflects it by name', () => {
+        const { wrapper } = makeServer();
+        wrapper.registerResource('my-resource', 'glsp://test', { title: 'res', mimeType: 'text/plain' }, async () => ({
+            contents: [{ uri: 'glsp://test', text: 'ok' }]
+        }));
+
+        const resources = wrapper.listResources();
+        expect(resources).to.have.lengthOf(1);
+        expect((resources[0] as RegisteredResource).name).to.equal('my-resource');
+        expect((resources[0] as RegisteredResource).title).to.equal('res');
+    });
+
+    it('tracks registerPrompt and listPrompts reflects it by description', () => {
+        const { wrapper } = makeServer();
+        wrapper.registerPrompt('describe', { description: 'desc' }, async () => ({ messages: [] }));
+
+        const prompts = wrapper.listPrompts();
+        expect(prompts).to.have.lengthOf(1);
+        expect(prompts[0].description).to.equal('desc');
+    });
+
+    it('getRawServer() returns the exact SDK instance passed in (escape hatch identity)', () => {
+        const { wrapper, sdk } = makeServer();
+        expect(wrapper.getRawServer()).to.equal(sdk);
+    });
+
+    it('dispose() invokes close() on the underlying SDK server', () => {
+        const { wrapper, sdk } = makeServer();
+        const closeSpy = sinon.spy(sdk, 'close');
+        wrapper.dispose();
+        expect(closeSpy.calledOnce).to.be.true;
+    });
+});

package/src/server/glsp-mcp-server.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 { Disposable, Logger, McpServerOptions } from '@eclipse-glsp/server';
+import {
+    McpServer,
+    RegisteredPrompt,
+    RegisteredResource,
+    RegisteredResourceTemplate,
+    RegisteredTool
+} from '@modelcontextprotocol/sdk/server/mcp.js';
+import { EmptyResultSchema, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { injectable, unmanaged } from 'inversify';
+
+export const GLSPMcpServer = Symbol('GLSPMcpServer');
+
+/** Either a static resource or a templated resource registration. */
+export type GLSPMcpResource = RegisteredResource | RegisteredResourceTemplate;
+
+/**
+ * Cadence for server-initiated `ping` requests on the standalone SSE GET stream. Shorter than
+ * typical client-side SSE read timeouts (e.g. undici's 5-min `bodyTimeout`) so the stream stays
+ * alive across chat-idle periods.
+ */
+const KEEP_ALIVE_INTERVAL_MS = 30_000;
+
+/** Per-ping timeout — short, since a ping with no SSE GET stream open will never resolve. */
+const KEEP_ALIVE_PING_TIMEOUT_MS = 5_000;
+
+/**
+ * Curated, per-session view onto the underlying MCP server. Handlers see this during
+ * registration; the launcher disposes it on session-close and on server shutdown.
+ */
+export interface GLSPMcpServer
+    extends Pick<McpServer, 'registerPrompt' | 'registerResource' | 'registerTool' | 'sendLoggingMessage' | 'isConnected' | 'connect'>,
+        Disposable {
+    readonly options: McpServerOptions;
+
+    /** Register a tool. Wraps the SDK's {@link McpServer.registerTool} and updates the local log. */
+    readonly registerTool: McpServer['registerTool'];
+    /** Register a resource. Wraps the SDK's {@link McpServer.registerResource} and updates the local log. */
+    readonly registerResource: McpServer['registerResource'];
+    /** Register a prompt. Wraps the SDK's {@link McpServer.registerPrompt} and updates the local log. */
+    readonly registerPrompt: McpServer['registerPrompt'];
+    /** Send an LLM-facing log message via the MCP `logging/message` notification. */
+    sendLoggingMessage: McpServer['sendLoggingMessage'];
+    /** True iff a transport is currently connected. */
+    isConnected: McpServer['isConnected'];
+    /** Attach the supplied transport. */
+    connect: McpServer['connect'];
+
+    listTools(): RegisteredTool[];
+    /** True iff a tool with this exact `name` has been registered on this server instance. */
+    hasTool(name: string): boolean;
+    listResources(): GLSPMcpResource[];
+    listPrompts(): RegisteredPrompt[];
+    /** Sends an MCP `ping` and resolves on empty result, rejects on transport timeout. */
+    ping(): Promise<void>;
+    /**
+     * Escape hatch to the underlying SDK `McpServer` for advanced APIs not covered by the
+     * stable surface. The returned value is the SDK type, not a stable GLSP surface.
+     */
+    getRawServer(): McpServer;
+}
+
+export const GLSPMcpServerFactory = Symbol('GLSPMcpServerFactory');
+
+/**
+ * Factory that produces a {@link GLSPMcpServer} per MCP client session.
+ * Bound to {@link DefaultGLSPMcpServer} by default; rebind to swap the
+ * implementation across all sessions.
+ */
+export type GLSPMcpServerFactory = (mcpServer: McpServer, options: McpServerOptions) => GLSPMcpServer;
+
+@injectable()
+export class DefaultGLSPMcpServer implements GLSPMcpServer {
+    protected readonly tools = new Map<string, RegisteredTool>();
+    protected readonly resources = new Map<string, GLSPMcpResource>();
+    protected readonly prompts = new Map<string, RegisteredPrompt>();
+    protected keepAliveTimer?: NodeJS.Timeout;
+
+    readonly registerTool: McpServer['registerTool'];
+    readonly registerResource: McpServer['registerResource'];
+    readonly registerPrompt: McpServer['registerPrompt'];
+
+    constructor(
+        @unmanaged() protected readonly mcpServer: McpServer,
+        @unmanaged() readonly options: McpServerOptions,
+        @unmanaged() protected readonly logger: Logger
+    ) {
+        // `register*` need an interception layer so the local registration log stays in
+        // sync; the Proxy preserves the SDK's generic signatures (which a wrapped method
+        // using `Parameters<>` would collapse, breaking adopter autocomplete on
+        // `inputSchema → handler arg shape`).
+        const { tools, resources, prompts } = this;
+        this.registerTool = new Proxy(mcpServer.registerTool.bind(mcpServer), {
+            apply(target, thisArg, args) {
+                const registered = Reflect.apply(target, thisArg, args);
+                if (typeof args[0] === 'string') {
+                    tools.set(args[0], registered);
+                }
+                return registered;
+            }
+        });
+        this.registerResource = new Proxy(mcpServer.registerResource.bind(mcpServer), {
+            apply(target, thisArg, args) {
+                const registered = Reflect.apply(target, thisArg, args);
+                if (typeof args[0] === 'string') {
+                    resources.set(args[0], registered);
+                }
+                return registered;
+            }
+        });
+        this.registerPrompt = new Proxy(mcpServer.registerPrompt.bind(mcpServer), {
+            apply(target, thisArg, args) {
+                const registered = Reflect.apply(target, thisArg, args);
+                if (typeof args[0] === 'string') {
+                    prompts.set(args[0], registered);
+                }
+                return registered;
+            }
+        });
+    }
+
+    sendLoggingMessage(...args: Parameters<McpServer['sendLoggingMessage']>): ReturnType<McpServer['sendLoggingMessage']> {
+        return this.mcpServer.sendLoggingMessage(...args);
+    }
+
+    async connect(...args: Parameters<McpServer['connect']>): ReturnType<McpServer['connect']> {
+        await this.mcpServer.connect(...args);
+        // Suppress the expected `RequestTimeout` when no SSE GET stream is open; surface other
+        // failures via debug. `unref` so a forgotten timer can't pin the process.
+        this.keepAliveTimer = setInterval(
+            () =>
+                this.ping().catch(err => {
+                    if (!(err instanceof McpError) || err.code !== ErrorCode.RequestTimeout) {
+                        this.logger.debug('MCP keep-alive ping failed:', err);
+                    }
+                }),
+            KEEP_ALIVE_INTERVAL_MS
+        );
+        this.keepAliveTimer.unref();
+    }
+
+    isConnected(): boolean {
+        return this.mcpServer.isConnected();
+    }
+
+    async ping(): Promise<void> {
+        // Bypass `Server.ping()` to pass a per-request timeout; SDK's no-arg wrapper uses the
+        // 60s default, which leaves keep-alive pings dangling for a full minute when no SSE GET
+        // stream is open.
+        await this.mcpServer.server.request({ method: 'ping' }, EmptyResultSchema, { timeout: KEEP_ALIVE_PING_TIMEOUT_MS });
+    }
+
+    listTools(): RegisteredTool[] {
+        return [...this.tools.values()];
+    }
+
+    hasTool(name: string): boolean {
+        return this.tools.has(name);
+    }
+
+    listResources(): GLSPMcpResource[] {
+        return [...this.resources.values()];
+    }
+
+    listPrompts(): RegisteredPrompt[] {
+        return [...this.prompts.values()];
+    }
+
+    getRawServer(): McpServer {
+        return this.mcpServer;
+    }
+
+    dispose(): void {
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = undefined;
+        }
+        this.mcpServer.close();
+    }
+}

package/src/server/lru-event-store.spec.ts

@@ -0,0 +1,121 @@
+/********************************************************************************
+ * 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 } from '@eclipse-glsp/server';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { expect } from 'chai';
+import { LruEventStore } from './lru-event-store';
+
+function jsonRpc(id: number): JSONRPCMessage {
+    return { jsonrpc: '2.0', id, result: { value: id } };
+}
+
+describe('LruEventStore', () => {
+    it('rejects an invalid limit (< 1)', () => {
+        expect(() => new LruEventStore(0)).to.throw(/limit must be >= 1/);
+        expect(() => new LruEventStore(-5)).to.throw(/limit must be >= 1/);
+    });
+
+    it('storeEvent returns a streamId-prefixed event id', async () => {
+        const store = new LruEventStore();
+        const id = await store.storeEvent('stream-A', jsonRpc(1));
+        expect(id.split('_')[0]).to.equal('stream-A');
+    });
+
+    it('evicts the oldest event once the cap is exceeded', async () => {
+        const store = new LruEventStore(3);
+        const id1 = await store.storeEvent('s', jsonRpc(1));
+        const id2 = await store.storeEvent('s', jsonRpc(2));
+        await store.storeEvent('s', jsonRpc(3));
+
+        expect(store.size).to.equal(3);
+
+        // Adding a 4th event evicts the oldest (id1).
+        const id4 = await store.storeEvent('s', jsonRpc(4));
+        expect(store.size).to.equal(3);
+
+        // Replay since id1 → can't find it (evicted) → returns ''.
+        const replayed: string[] = [];
+        const streamId = await store.replayEventsAfter(id1, {
+            send: async eventId => {
+                replayed.push(eventId);
+            }
+        });
+        expect(streamId).to.equal(''); // id1 has been evicted
+        expect(replayed).to.have.lengthOf(0);
+
+        // Replay since id2 still works — id3 (still in store) and id4 are sent in order.
+        const replayedFromId2: string[] = [];
+        await store.replayEventsAfter(id2, {
+            send: async eventId => {
+                replayedFromId2.push(eventId);
+            }
+        });
+        expect(replayedFromId2).to.have.lengthOf(2);
+        expect(replayedFromId2[1]).to.equal(id4);
+    });
+
+    it('replays only events from the same stream after the lastEventId', async () => {
+        const store = new LruEventStore();
+        const a1 = await store.storeEvent('A', jsonRpc(1));
+        await store.storeEvent('B', jsonRpc(2)); // different stream — must be skipped
+        const a3 = await store.storeEvent('A', jsonRpc(3));
+        const a4 = await store.storeEvent('A', jsonRpc(4));
+
+        const replayed: Array<{ id: string; msg: JSONRPCMessage }> = [];
+        const streamId = await store.replayEventsAfter(a1, {
+            send: async (id, msg) => {
+                replayed.push({ id, msg });
+            }
+        });
+
+        expect(streamId).to.equal('A');
+        expect(replayed.map(e => e.id)).to.deep.equal([a3, a4]);
+    });
+
+    it('returns "" when lastEventId is unknown', async () => {
+        const store = new LruEventStore();
+        await store.storeEvent('A', jsonRpc(1));
+
+        const streamId = await store.replayEventsAfter('A_999_xxx', {
+            send: async () => {
+                throw new Error('should not be called');
+            }
+        });
+
+        expect(streamId).to.equal('');
+    });
+
+    it('logs a cap-eviction warn when replaying an evicted last-event-id', async () => {
+        const warns: string[] = [];
+        const logger = { warn: (message: string) => warns.push(message) } as unknown as Logger;
+        const store = new LruEventStore(2, logger);
+        const evictedId = await store.storeEvent('s', jsonRpc(1));
+        await store.storeEvent('s', jsonRpc(2));
+        await store.storeEvent('s', jsonRpc(3));
+
+        const streamId = await store.replayEventsAfter(evictedId, {
+            send: async () => {
+                throw new Error('should not be called');
+            }
+        });
+
+        expect(streamId).to.equal('');
+        expect(warns).to.have.lengthOf(1);
+        expect(warns[0]).to.match(/Replay miss/);
+        expect(warns[0]).to.include('Cap is 2');
+    });
+});