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

package/src/{server → common/server}/mcp-input-schemas.ts

@@ -73,6 +73,19 @@ export const ElementIdentitySchema = z.object({
 /** Inferred shape of {@link ElementIdentitySchema} — see its docstring for usage. */
 export type ElementIdentity = z.infer<typeof ElementIdentitySchema>;
 
+/**
+ * Shared output field for mutating tools — the number of underlying GLSP operations a single
+ * call dispatched. Adopters chain `undo` / `redo` against this count to roll back or replay a
+ * full user action (a single MCP call may produce several commands, e.g. create-with-label).
+ * Always non-negative; `0` when nothing was dispatched (e.g. all inputs hit a pre-dispatch
+ * validation error).
+ */
+export const dispatchedCommands = z
+    .number()
+    .int()
+    .nonnegative()
+    .describe('Number of underlying GLSP operations dispatched. Useful when chaining `undo` / `redo`.');
+
 /**
  * Inferred shape of {@link McpDiagramScopedInputSchema} — `{ sessionId: string }`. Any
  * adopter input schema that extends `McpDiagramScopedInputSchema` infers a type structurally

package/src/{server → common/server}/mcp-log-level-registry.ts

@@ -21,7 +21,7 @@ export const McpLogLevelRegistry = Symbol('McpLogLevelRegistry');
 
 /**
  * Per-MCP-session minimum-severity threshold for `notifications/message`. Updated by the
- * server's `logging/setLevel` request handler (registered in {@link McpServerLauncher} on
+ * server's `logging/setLevel` request handler (registered in {@link AbstractMcpServerLauncher} on
  * session-init); read by {@link McpLogger} to gate message delivery.
  *
  * Bound as a server-scope singleton: one registry shared across MCP sessions, keyed by

package/src/{server → common/server}/mcp-logger.spec.ts

@@ -20,7 +20,8 @@ import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import { DefaultMcpLogLevelRegistry, McpLogLevelRegistry } from './mcp-log-level-registry';
 import { McpLogger } from './mcp-logger';
-import { McpRequestExtra, mcpRequestContext } from './mcp-request-context';
+import { NodeMcpRequestContext } from '../../node/server/node-mcp-request-context';
+import { McpRequestContext, McpRequestExtra } from './mcp-request-context';
 
 interface RecordedLog {
     level: string;
@@ -43,18 +44,25 @@ class RecordingLogger extends NullLogger {
     }
 }
 
-function buildLogger(): { logger: McpLogger; glspLogger: RecordingLogger; levelRegistry: DefaultMcpLogLevelRegistry } {
+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 };
+    return { logger: container.get(McpLogger), glspLogger, levelRegistry, requestContext };
 }
 
 /**
@@ -92,12 +100,12 @@ describe('McpLogger', () => {
         });
     });
 
-    describe('inside an mcpRequestContext.run frame', () => {
+    describe('inside an requestContext.run frame', () => {
         it('emits notifications/message to the bound MCP client AND the GLSP Logger', async () => {
-            const { logger, glspLogger } = buildLogger();
+            const { logger, glspLogger, requestContext } = buildLogger();
             const { extra, sent } = buildExtra();
 
-            await mcpRequestContext.run(extra, async () => {
+            await requestContext.run(extra, async () => {
                 logger.info('one');
                 logger.warn('two');
                 logger.error('three');
@@ -122,14 +130,14 @@ describe('McpLogger', () => {
         });
 
         it('swallows transport failures so a broken MCP send never breaks the producing tool', async () => {
-            const { logger, glspLogger } = buildLogger();
+            const { logger, glspLogger, requestContext } = buildLogger();
             const failingExtra = {
                 sendNotification: async () => {
                     throw new Error('transport closed');
                 }
             } as unknown as McpRequestExtra;
 
-            await mcpRequestContext.run(failingExtra, async () => {
+            await requestContext.run(failingExtra, async () => {
                 expect(() => logger.error('still works')).to.not.throw();
                 await new Promise(resolve => setImmediate(resolve));
             });
@@ -141,17 +149,17 @@ describe('McpLogger', () => {
 
     describe('concurrent request contexts', () => {
         it('keeps each request frame isolated via AsyncLocalStorage', async () => {
-            const { logger } = buildLogger();
+            const { logger, requestContext } = buildLogger();
             const { extra: extraA, sent: sentA } = buildExtra();
             const { extra: extraB, sent: sentB } = buildExtra();
 
             await Promise.all([
-                mcpRequestContext.run(extraA, async () => {
+                requestContext.run(extraA, async () => {
                     logger.info('A');
                     await new Promise(resolve => setImmediate(resolve));
                     logger.info('A-after-yield');
                 }),
-                mcpRequestContext.run(extraB, async () => {
+                requestContext.run(extraB, async () => {
                     logger.info('B');
                     await new Promise(resolve => setImmediate(resolve));
                     logger.info('B-after-yield');
@@ -165,12 +173,12 @@ describe('McpLogger', () => {
 
     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 } = buildLogger();
+            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 mcpRequestContext.run(extra, async () => {
+            await requestContext.run(extra, async () => {
                 logger.info('chatty');
                 logger.debug('verbose');
                 logger.warn('important');
@@ -185,19 +193,19 @@ describe('McpLogger', () => {
         });
 
         it('isolates thresholds across sessions (different setLevel per session id)', async () => {
-            const { logger, levelRegistry } = buildLogger();
+            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([
-                mcpRequestContext.run(extraA, async () => {
+                requestContext.run(extraA, async () => {
                     logger.info('A-info');
                     logger.error('A-error');
                     await new Promise(resolve => setImmediate(resolve));
                 }),
-                mcpRequestContext.run(extraB, async () => {
+                requestContext.run(extraB, async () => {
                     logger.info('B-info');
                     logger.error('B-error');
                     await new Promise(resolve => setImmediate(resolve));
@@ -209,11 +217,11 @@ describe('McpLogger', () => {
         });
 
         it('default threshold (no setLevel sent) lets every level through (preserves prior behavior)', async () => {
-            const { logger } = buildLogger();
+            const { logger, requestContext } = buildLogger();
             const { extra, sent } = buildExtra('session-default');
             // No setLevel call → default threshold = 'debug' → everything emitted.
 
-            await mcpRequestContext.run(extra, async () => {
+            await requestContext.run(extra, async () => {
                 logger.debug('d');
                 logger.info('i');
                 logger.warn('w');

package/src/{server → common/server}/mcp-logger.ts

@@ -16,16 +16,16 @@
 
 import { Logger } from '@eclipse-glsp/server';
 import type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, optional } from 'inversify';
 import { McpLogLevelRegistry, passesLogThreshold } from './mcp-log-level-registry';
-import { mcpRequestContext } from './mcp-request-context';
+import { McpRequestContext, NoopMcpRequestContext } from './mcp-request-context';
 
 /**
  * Logger that writes to BOTH the GLSP-side server log and the connected MCP client.
  *
  * Mirrors the {@link Logger} shape so handlers can drop-in switch from `@inject(Logger)` to
  * `@inject(McpLogger)`. The server-side route always fires; the MCP-side route fires only when
- * a call is made from inside an MCP request callback (tracked via {@link mcpRequestContext}).
+ * a call is made from inside an MCP request callback (tracked via {@link McpRequestContext}).
  *
  * We deliberately do NOT auto-forward arbitrary GLSP `Logger.info` calls to MCP clients —
  * that would leak unrelated server-wide log lines into every connected LLM. Adopters opt in
@@ -38,13 +38,17 @@ import { mcpRequestContext } from './mcp-request-context';
  *  - `debug` → `debug`
  *
  * Shared across MCP clients on the same GLSP session; per-client routing is handled by the
- * active `mcpRequestContext` frame, and the per-MCP-session `logging/setLevel` threshold is
+ * active `McpRequestContext` frame, and the per-MCP-session `logging/setLevel` threshold is
  * stored in {@link McpLogLevelRegistry}.
  *
  * @experimental
  */
 @injectable()
 export class McpLogger {
+    @inject(McpRequestContext)
+    @optional()
+    protected requestContext: McpRequestContext = new NoopMcpRequestContext();
+
     @inject(Logger) protected glspLogger: Logger;
 
     @inject(McpLogLevelRegistry) protected levelRegistry: McpLogLevelRegistry;
@@ -78,7 +82,7 @@ export class McpLogger {
      * Failures to deliver are swallowed — a broken transport must not break the producing tool.
      */
     protected notify(level: LoggingLevel, data: string): void {
-        const extra = mcpRequestContext.getStore();
+        const extra = this.requestContext.getStore();
         if (!extra) {
             return;
         }

package/src/{server → common/server}/mcp-options.ts

@@ -37,7 +37,7 @@ export class McpServerOptions {
 /**
  * DI binding identifier for adopter-provided default options. Supplied via the
  * {@link AbstractMcpServerModule} constructor and merged with init-time options by
- * `McpServerLauncher.initializeServer` — init-time wins per field.
+ * `AbstractMcpServerLauncher.initializeServer` — init-time wins per field.
  */
 export const McpServerDefaults = Symbol('McpServerDefaults');
 export type McpServerDefaults = McpServerOptionsType;

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

@@ -17,7 +17,9 @@
 import { ServerNotification } from '@modelcontextprotocol/sdk/types.js';
 import { expect } from 'chai';
 import { McpProgressReporter } from './mcp-progress-reporter';
-import { McpRequestExtra, mcpRequestContext } from './mcp-request-context';
+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[] = [];
@@ -30,12 +32,20 @@ function buildExtra(progressToken?: string | number): { extra: 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 = new McpProgressReporter();
+        const { reporter, requestContext } = buildReporter();
         const { extra, sent } = buildExtra(undefined);
 
-        await mcpRequestContext.run(extra, async () => {
+        await requestContext.run(extra, async () => {
             await reporter.emit({ progress: 0, message: 'starting' });
         });
 
@@ -43,10 +53,10 @@ describe('McpProgressReporter', () => {
     });
 
     it('emits notifications/progress when the request carries a progressToken', async () => {
-        const reporter = new McpProgressReporter();
+        const { reporter, requestContext } = buildReporter();
         const { extra, sent } = buildExtra('tok-42');
 
-        await mcpRequestContext.run(extra, async () => {
+        await requestContext.run(extra, async () => {
             await reporter.emit({ progress: 0, message: 'starting' });
             await reporter.emit({ progress: 1, total: 3, message: 'step 1/3' });
         });
@@ -63,10 +73,10 @@ describe('McpProgressReporter', () => {
     });
 
     it('accepts numeric progress tokens', async () => {
-        const reporter = new McpProgressReporter();
+        const { reporter, requestContext } = buildReporter();
         const { extra, sent } = buildExtra(7);
 
-        await mcpRequestContext.run(extra, async () => {
+        await requestContext.run(extra, async () => {
             await reporter.emit({ progress: 0 });
         });
 
@@ -75,7 +85,7 @@ describe('McpProgressReporter', () => {
     });
 
     it('swallows transport failures so a broken send never breaks the producing tool', async () => {
-        const reporter = new McpProgressReporter();
+        const { reporter, requestContext } = buildReporter();
         const failingExtra = {
             sendNotification: async () => {
                 throw new Error('transport closed');
@@ -83,7 +93,7 @@ describe('McpProgressReporter', () => {
             _meta: { progressToken: 'tok-1' }
         } as unknown as McpRequestExtra;
 
-        await mcpRequestContext.run(failingExtra, async () => {
+        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.

package/src/{server → common/server}/mcp-progress-reporter.ts

@@ -14,8 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { injectable } from 'inversify';
-import { mcpRequestContext } from './mcp-request-context';
+import { inject, injectable, optional } from 'inversify';
+import { McpRequestContext, NoopMcpRequestContext } from './mcp-request-context';
 
 /**
  * Per-call shape of a `notifications/progress` emission. Mirrors the SDK's
@@ -33,7 +33,7 @@ export interface McpProgressBeat {
 
 /**
  * Emits `notifications/progress` to the connected MCP client when the active request carries a
- * `progressToken` in its `_meta`. Built on the same {@link mcpRequestContext} as
+ * `progressToken` in its `_meta`. Built on the same {@link McpRequestContext} as
  * {@link McpLogger}; handlers don't need to thread `extra` through their own signatures.
  *
  * Behaviour:
@@ -43,14 +43,18 @@ export interface McpProgressBeat {
  *  - Failures to deliver are swallowed: a broken transport must not break the producing tool.
  *
  * Shared across MCP clients on the same GLSP session; per-client routing is handled by the
- * active `mcpRequestContext` frame.
+ * active `McpRequestContext` frame.
  *
  * @experimental
  */
 @injectable()
 export class McpProgressReporter {
+    @inject(McpRequestContext)
+    @optional()
+    protected requestContext: McpRequestContext = new NoopMcpRequestContext();
+
     async emit(beat: McpProgressBeat): Promise<void> {
-        const extra = mcpRequestContext.getStore();
+        const extra = this.requestContext.getStore();
         const progressToken = extra?._meta?.progressToken;
         if (extra === undefined || progressToken === undefined) {
             return;

package/src/{server → common/server}/mcp-prompt-handler.ts

@@ -15,13 +15,13 @@
  ********************************************************************************/
 
 import { ClientId, Logger, MaybePromise, ModelState } from '@eclipse-glsp/server';
-import { inject, injectable, interfaces } from 'inversify';
+import { inject, injectable, interfaces, optional } from 'inversify';
 import { ZodObject, ZodRawShape } from 'zod/v4';
 import { GLSPMcpServer } from './glsp-mcp-server';
 import { McpPromptResult, McpToolError, extractErrorMessage } from './mcp-handler-shared';
 import { McpIdAliasService } from './mcp-id-alias-service';
 import { McpDiagramScopedInput } from './mcp-input-schemas';
-import { mcpRequestContext } from './mcp-request-context';
+import { McpRequestContext, NoopMcpRequestContext } from './mcp-request-context';
 
 /**
  * Multi-binding key for **server-scope** prompt handlers — singletons that don't target a
@@ -45,6 +45,10 @@ export const McpPromptHandler = Symbol('McpPromptHandler');
 /** Shared infrastructure for both server- and diagram-scope prompt handlers. */
 @injectable()
 abstract class BaseMcpPromptHandler {
+    @inject(McpRequestContext)
+    @optional()
+    protected requestContext: McpRequestContext = new NoopMcpRequestContext();
+
     @inject(Logger) protected logger: Logger;
 
     /**
@@ -113,7 +117,7 @@ export abstract class AbstractMcpPromptHandler<T = Record<string, unknown>> exte
 
     registerPrompt(server: GLSPMcpServer): void {
         server.registerPrompt(this.name, this.toRegistrationConfig(), async (args, extra) =>
-            mcpRequestContext.run(extra, () => this.execute(() => this.createResult(args as T)))
+            this.requestContext.run(extra, () => this.execute(() => this.createResult(args as T)))
         );
     }
 }
@@ -141,7 +145,7 @@ export abstract class AbstractMcpDiagramPromptHandler<
     protected abstract createResult(args: T): MaybePromise<McpPromptResult>;
 
     /**
-     * Public dispatch entry point invoked by {@link McpServerLauncher}'s SDK callback.
+     * Public dispatch entry point invoked by {@link AbstractMcpServerLauncher}'s SDK callback.
      */
     handle(args: T): Promise<McpPromptResult> {
         return this.execute(() => this.createResult(args));

package/src/{server → common/server}/mcp-request-context.ts

@@ -16,24 +16,28 @@
 
 import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types.js';
-import { AsyncLocalStorage } from 'node:async_hooks';
 
 export type McpRequestExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
 
+export const McpRequestContext = Symbol('McpRequestContext');
+
 /**
- * Module-level `AsyncLocalStorage` carrying the SDK's per-request `extra` (notification sender,
- * progress token, request id, session id) for the duration of a tool/resource/prompt callback.
- *
- * The handler bases (tool / resource / prompt) wrap each registered SDK callback in
- * `mcpRequestContext.run(extra, () => …)`. Anything inside the handler — and any await chain
- * branching off it — can read the active context via {@link mcpRequestContext.getStore}.
- *
- * This lets {@link McpLogger} forward logs to the MCP client without every handler having to
- * thread `extra` through its own signature, and lets future progress-emission code (P1f / PNG
- * export) reach the same channel from inside `requestUntil` chains.
- *
- * Concurrent requests on the same MCP session each get their own AsyncLocalStorage frame —
- * no cross-talk. Code that runs OUTSIDE a request (init contributions, background timers)
- * sees `undefined` from `getStore()`.
+ * Carries the SDK's per-request `extra` (notification sender, progress token, request id,
+ * session id) for the duration of a tool/resource/prompt callback so consumers like the MCP
+ * logger and progress reporter can reach the client without threading `extra` through their
+ * own signatures.
  */
-export const mcpRequestContext = new AsyncLocalStorage<McpRequestExtra>();
+export interface McpRequestContext {
+    run<R>(extra: McpRequestExtra, callback: () => R): R;
+    getStore(): McpRequestExtra | undefined;
+}
+
+/** No-op fallback used when no implementation is bound (e.g. in unit tests). */
+export class NoopMcpRequestContext implements McpRequestContext {
+    run<R>(_extra: McpRequestExtra, callback: () => R): R {
+        return callback();
+    }
+    getStore(): McpRequestExtra | undefined {
+        return undefined;
+    }
+}

package/src/{server → common/server}/mcp-resource-handler.ts

@@ -18,7 +18,7 @@ import { ActionDispatcher, ClientId, Logger, MaybePromise, ModelState, RequestAc
 import { CompleteResourceTemplateCallback, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Variables } from '@modelcontextprotocol/sdk/shared/uriTemplate.js';
 import { Annotations, ListResourcesResult, Role } from '@modelcontextprotocol/sdk/types.js';
-import { inject, injectable, interfaces } from 'inversify';
+import { inject, injectable, interfaces, optional } from 'inversify';
 import { ZodObject, ZodRawShape } from 'zod/v4';
 import { GLSPMcpServer } from './glsp-mcp-server';
 import {
@@ -33,7 +33,7 @@ import {
 import { McpIdAliasService } from './mcp-id-alias-service';
 import { McpDiagramScopedInput } from './mcp-input-schemas';
 import { McpMimeType } from './mcp-mime-types';
-import { mcpRequestContext } from './mcp-request-context';
+import { McpRequestContext, NoopMcpRequestContext } from './mcp-request-context';
 
 /**
  * Multi-binding key for **server-scope** resource handlers — singletons that don't target a
@@ -55,6 +55,10 @@ export type McpResourceUri = string | { template: string };
 /** Shared infrastructure for both server- and diagram-scope resource handlers. */
 @injectable()
 abstract class BaseMcpResourceHandler {
+    @inject(McpRequestContext)
+    @optional()
+    protected requestContext: McpRequestContext = new NoopMcpRequestContext();
+
     @inject(Logger) protected logger: Logger;
 
     /**
@@ -184,7 +188,7 @@ abstract class BaseMcpResourceHandler {
     /** Builds the SDK `ResourceTemplate` for templated URIs (server-scope path). */
     protected buildResourceTemplate(template: string): ResourceTemplate {
         return new ResourceTemplate(template, {
-            list: this.list ? async extra => mcpRequestContext.run(extra, () => this.list!()) : undefined,
+            list: this.list ? async extra => this.requestContext.run(extra, () => this.list!()) : undefined,
             complete: this.complete?.()
         });
     }
@@ -217,11 +221,11 @@ export abstract class AbstractMcpResourceHandler<T = Record<string, unknown>> ex
         if (typeof this.uri === 'string') {
             const uri = this.uri;
             server.registerResource(this.name, uri, config, async (_uri, extra) =>
-                mcpRequestContext.run(extra, async () => this.toResourceResult(uri, await this.execute(() => this.createResult({} as T))))
+                this.requestContext.run(extra, async () => this.toResourceResult(uri, await this.execute(() => this.createResult({} as T))))
             );
         } else {
             server.registerResource(this.name, this.buildResourceTemplate(this.uri.template), config, async (uri, params, extra) =>
-                mcpRequestContext.run(extra, async () =>
+                this.requestContext.run(extra, async () =>
                     this.toResourceResult(uri.toString(), await this.execute(() => this.createResult(toParams(params) as T)))
                 )
             );
@@ -250,7 +254,7 @@ export abstract class AbstractMcpResourceHandler<T = Record<string, unknown>> ex
                 outputSchema: this.toolAlternativeOutputSchema
             },
             async (params, extra) =>
-                mcpRequestContext.run(extra, async () => this.toToolResult(await this.execute(() => this.createResult(params as T))))
+                this.requestContext.run(extra, async () => this.toToolResult(await this.execute(() => this.createResult(params as T))))
         );
     }
 }
@@ -330,7 +334,7 @@ export abstract class AbstractMcpDiagramResourceHandler<
     }
 
     /**
-     * Public dispatch entry point invoked by {@link McpServerLauncher}'s SDK callback for
+     * Public dispatch entry point invoked by {@link AbstractMcpServerLauncher}'s SDK callback for
      * resource reads. The launcher passes the URI it received from the SDK plus the URI-template
      * variable values normalized into a flat record.
      */

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

@@ -106,13 +106,13 @@ const matrix: Array<{
         name: 'create-nodes',
         Constructor: CreateNodesMcpToolHandler,
         schema: CreateNodesOutputSchema,
-        sample: { createdNodes: [{ id: 'n1', elementTypeId: 'node:foo' }], errors: [], warnings: [] }
+        sample: { createdNodes: [{ id: 'n1', elementTypeId: 'node:foo' }], dispatchedCommands: 1, errors: [], warnings: [] }
     },
     {
         name: 'create-edges',
         Constructor: CreateEdgesMcpToolHandler,
         schema: CreateEdgesOutputSchema,
-        sample: { createdEdges: [{ id: 'e1', elementTypeId: 'edge' }], errors: [] }
+        sample: { createdEdges: [{ id: 'e1', elementTypeId: 'edge' }], dispatchedCommands: 1, errors: [] }
     },
     {
         name: 'modify-nodes',
@@ -130,11 +130,11 @@ const matrix: Array<{
         name: 'delete-elements',
         Constructor: DeleteElementsMcpToolHandler,
         schema: DeleteElementsOutputSchema,
-        sample: { deletedElements: [{ id: 'n1', elementTypeId: 'node:foo' }], deletedCount: 3 }
+        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 } },
+    { name: 'layout', Constructor: LayoutMcpToolHandler, schema: LayoutOutputSchema, sample: { applied: true, dispatchedCommands: 1 } },
     {
         name: 'validate-diagram',
         Constructor: ValidateDiagramMcpToolHandler,

package/src/{server → common/server}/mcp-tool-handler.ts

@@ -25,7 +25,7 @@ import {
     ResponseAction
 } from '@eclipse-glsp/server';
 import { ToolAnnotations } from '@modelcontextprotocol/sdk/types';
-import { inject, injectable, interfaces } from 'inversify';
+import { inject, injectable, interfaces, optional } from 'inversify';
 import { ZodObject, ZodRawShape } from 'zod/v4';
 import { GLSPMcpServer } from './glsp-mcp-server';
 import {
@@ -44,7 +44,7 @@ import {
 import { McpIdAliasService } from './mcp-id-alias-service';
 import { ElementIdentity, McpDiagramScopedInput } from './mcp-input-schemas';
 import { McpLabelProvider } from './mcp-label-provider';
-import { mcpRequestContext } from './mcp-request-context';
+import { McpRequestContext, NoopMcpRequestContext } from './mcp-request-context';
 
 /**
  * Multi-binding key for **server-scope** tool handlers — singletons that don't target a
@@ -75,6 +75,10 @@ export const McpToolHandler = Symbol('McpToolHandler');
  */
 @injectable()
 export abstract class BaseMcpToolHandler {
+    @inject(McpRequestContext)
+    @optional()
+    protected requestContext: McpRequestContext = new NoopMcpRequestContext();
+
     @inject(Logger) protected logger: Logger;
 
     /**
@@ -222,7 +226,7 @@ export abstract class AbstractMcpToolHandler<T = Record<string, unknown>> extend
 
     registerTool(server: GLSPMcpServer): void {
         server.registerTool(this.name, this.toRegistrationConfig(), async (params, extra) =>
-            mcpRequestContext.run(extra, () => this.execute(() => this.createResult(params as T)))
+            this.requestContext.run(extra, () => this.execute(() => this.createResult(params as T)))
         );
     }
 }
@@ -253,7 +257,7 @@ export abstract class BaseMcpDiagramToolHandler<T extends McpDiagramScopedInput
     protected abstract createResult(params: T): MaybePromise<McpToolResult>;
 
     /**
-     * Public dispatch entry point invoked by {@link McpServerLauncher}'s registered SDK
+     * Public dispatch entry point invoked by {@link AbstractMcpServerLauncher}'s registered SDK
      * callback. Each sibling sets its own policy — {@link AbstractMcpDiagramToolHandler}
      * passes through; {@link OperationMcpDiagramToolHandler} enforces the readonly gate.
      * Adopters don't call this directly.

package/src/{tools → common/tools}/handlers/create-edges-mcp-tool-handler.ts

@@ -18,7 +18,13 @@ import { ChangeRoutingPointsOperation, CreateEdgeOperation, DiagramConfiguration
 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 {
+    ElementIdentity,
+    ElementIdentitySchema,
+    McpDiagramScopedInputSchema,
+    dispatchedCommands,
+    position
+} from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 import { formatNoticeList } from '../../util/mcp-util';
 
@@ -53,6 +59,7 @@ export const CreateEdgesValidationResultSchema = z.object({
 
 export const CreateEdgesOutputSchema = z.object({
     createdEdges: z.array(ElementIdentitySchema).describe('Identity of each edge successfully created. Empty in `dryRun` mode.'),
+    dispatchedCommands,
     errors: z.array(z.string()).describe('Per-input failure messages; absent or empty when every input succeeded.'),
     validationResults: z
         .array(CreateEdgesValidationResultSchema)
@@ -159,7 +166,7 @@ export class CreateEdgesMcpToolHandler extends OperationMcpDiagramToolHandler<Cr
         // 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 }
+            { createdEdges, dispatchedCommands: dispatchedOperations, errors }
         );
     }
 

package/src/{tools → common/tools}/handlers/create-nodes-mcp-tool-handler.ts

@@ -18,7 +18,13 @@ import { ApplyLabelEditOperation, CreateNodeOperation } from '@eclipse-glsp/serv
 import { injectable } 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 {
+    ElementIdentity,
+    ElementIdentitySchema,
+    McpDiagramScopedInputSchema,
+    dispatchedCommands,
+    position
+} from '../../server/mcp-input-schemas';
 import { OperationMcpDiagramToolHandler } from '../../server/mcp-tool-handler';
 import { formatNoticeList } from '../../util/mcp-util';
 
@@ -43,6 +49,7 @@ export const CreateNodesOutputSchema = z.object({
     createdNodes: z
         .array(ElementIdentitySchema)
         .describe('Nodes successfully created, in input order. `label` is only present when the type actually accepted text.'),
+    dispatchedCommands,
     errors: z.array(z.string()).describe('Per-input hard-failure messages — the creation could not complete.'),
     warnings: z
         .array(z.string())
@@ -120,7 +127,7 @@ export class CreateNodesMcpToolHandler extends OperationMcpDiagramToolHandler<Cr
             `Successfully created ${createdNodes.length} node(s) (in ${dispatchedOperations} commands):\n${successListStr}` +
                 formatNoticeList('errors', errors) +
                 formatNoticeList('warnings', warnings),
-            { createdNodes, errors, warnings }
+            { createdNodes, dispatchedCommands: dispatchedOperations, errors, warnings }
         );
     }
 }