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

package/lib/server/mcp-tool-handler.d.ts

@@ -0,0 +1,259 @@
+/********************************************************************************
+ * Copyright (c) 2025-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 { ActionDispatcher, GModelElement, Logger, MaybePromise, ModelState, RequestAction, ResponseAction } from '@eclipse-glsp/server';
+import { ToolAnnotations } from '@modelcontextprotocol/sdk/types';
+import { interfaces } from 'inversify';
+import { ZodObject, ZodRawShape } from 'zod/v4';
+import { GLSPMcpServer } from './glsp-mcp-server';
+import { McpStructuredContent, McpToolErrorCode, McpToolResult } from './mcp-handler-shared';
+import { McpIdAliasService } from './mcp-id-alias-service';
+import { ElementIdentity, McpDiagramScopedInput } from './mcp-input-schemas';
+import { McpLabelProvider } from './mcp-label-provider';
+/**
+ * Multi-binding key for **server-scope** tool handlers — singletons that don't target a
+ * specific GLSP client session. Adopters extend {@link AbstractMcpToolHandler} and bind their
+ * subclass against this symbol; the launcher invokes `registerTool(server)` on each at
+ * MCP-session-init.
+ *
+ * Diagram-scope tools (one instance per open diagram) use the separate
+ * {@link McpDiagramToolHandlerConstructor} multi-binding instead — see `mcp-session.ts` for
+ * the MCP-session vs GLSP-session terminology.
+ *
+ * @experimental
+ */
+export interface McpToolHandler {
+    registerTool(server: GLSPMcpServer): void;
+}
+export declare const McpToolHandler: unique symbol;
+/**
+ * Shared infrastructure for both server- and diagram-scope tool handlers — exported so adopters
+ * who want to factor common helpers across server-scope and diagram-scope tools can extend a
+ * single ancestor instead of duplicating logic. Most adopters extend the more specific siblings
+ * ({@link AbstractMcpToolHandler}, {@link AbstractMcpDiagramToolHandler},
+ * {@link OperationMcpDiagramToolHandler}); reach for this base only when a helper is genuinely
+ * scope-agnostic.
+ *
+ * @experimental
+ */
+export declare abstract class BaseMcpToolHandler {
+    protected logger: Logger;
+    /**
+     * Tool identifier exposed to the MCP client. Also used to reference this tool from other
+     * handlers' prompt or description text — wire via `static readonly NAME = '…'` and
+     * `readonly name = ClassName.NAME` so those cross-references survive renames.
+     */
+    abstract readonly name: string;
+    /** LLM-facing explanation surfaced in the tool catalog — clients pass this verbatim to the model. Keep concise and behavioral. */
+    abstract readonly description: string;
+    /** Adopter writes `z.object({ ... })`; the base passes `.shape` to the SDK. */
+    abstract readonly inputSchema: ZodObject<ZodRawShape>;
+    /**
+     * Optional dual-emit schema. When set, pass the matching `structured` payload to
+     * {@link success} so the framework forwards it as `structuredContent` alongside the
+     * human-readable text. The MCP spec says clients SHOULD validate `structuredContent`
+     * against the declared schema, so the two MUST stay in sync.
+     */
+    readonly outputSchema?: ZodObject<ZodRawShape>;
+    /** Optional human-friendly display name for UIs that render a friendlier label than `name`. */
+    readonly title?: string;
+    /**
+     * Tool does not modify its environment. Defaults to `true` here on the common base;
+     * overridden to `false` on {@link OperationMcpDiagramToolHandler} since write-style tools
+     * dispatch model-mutating operations.
+     */
+    readonly readOnlyHint: boolean;
+    /**
+     * Tool may perform destructive *updates* (irreversible deletion, data loss). Only meaningful
+     * when `readOnlyHint: false`. Set explicitly on the concrete handler when it applies (e.g.
+     * `delete-elements`).
+     */
+    readonly destructiveHint?: boolean;
+    /**
+     * Repeated calls with the same arguments have no additional effect. Only meaningful when
+     * `readOnlyHint: false`.
+     */
+    readonly idempotentHint?: boolean;
+    /**
+     * Tool interacts with an "open world" of external entities (web search, external APIs).
+     * Default in this codebase: `false` — diagram ops are bounded to the GLSP client. Set
+     * `true` for tools that reach off-process.
+     */
+    readonly openWorldHint: boolean;
+    /**
+     * SDK-facing registration config; consumed by both the server-scope `registerTool` flow and
+     * the launcher's diagram-scope dispatcher. Assembles the {@link ToolAnnotations} object from
+     * the flat-field surface so adopters compose annotations via field overrides, not by
+     * redeclaring the whole annotations literal.
+     */
+    toRegistrationConfig(): {
+        title?: string;
+        description: string;
+        inputSchema: ZodObject<ZodRawShape>;
+        outputSchema?: ZodObject<ZodRawShape>;
+        annotations: ToolAnnotations;
+    };
+    protected error(message: string, code?: McpToolErrorCode): McpToolResult;
+    /**
+     * Convention: `message` is a short, referenceable summary (ids, types, counts); `structured`
+     * carries the full payload. The two complement rather than duplicate — balancing token usage
+     * across the heterogeneous client landscape.
+     *
+     * The MCP spec (2025-06-18) recommends mirroring `structuredContent` into a TextContent
+     * block, but in-flight discussion is softening that — `content` and `structuredContent` are
+     * increasingly model-oriented vs. machine-oriented surfaces that should be semantically
+     * equivalent, not byte-identical.
+     *
+     * Client behavior is uneven, so summary-in-content + payload-in-structured is a deliberate
+     * hedge: some clients only forward `structuredContent`, some only `content`, some forward
+     * both verbatim and double the per-call context budget.
+     *
+     * Pass `structured` whenever {@link outputSchema} is declared (the spec says clients SHOULD
+     * validate against the declared shape). Omit for plain text-only responses.
+     */
+    protected success(message: string, structured?: McpStructuredContent): McpToolResult;
+    /** Catches `McpToolError` (→ `isError: true` result) and unexpected errors; tags known errors via {@link errorCodeFor}. */
+    protected execute(producer: () => MaybePromise<McpToolResult>): Promise<McpToolResult>;
+}
+/**
+ * Server-scope tool base — for tools that don't target a specific GLSP client session
+ * (e.g., listing all sessions). Bound under {@link McpToolHandler} as a server-scope singleton;
+ * the launcher invokes `registerTool(server)` once per MCP session.
+ *
+ * @experimental
+ */
+export declare abstract class AbstractMcpToolHandler<T = Record<string, unknown>> extends BaseMcpToolHandler implements McpToolHandler {
+    /** Throw {@link McpToolError} for expected, user-facing errors; the base wraps. */
+    protected abstract createResult(params: T): MaybePromise<McpToolResult>;
+    registerTool(server: GLSPMcpServer): void;
+}
+/**
+ * Shared per-session implementation for diagram-scope tool handlers. Adopters don't extend this
+ * directly — extend {@link AbstractMcpDiagramToolHandler} (read) or {@link OperationMcpDiagramToolHandler}
+ * (write). Exported only as the upper bound for the {@link McpDiagramToolHandlerConstructor}
+ * multi-binding.
+ *
+ * `@inject(...)` fields resolve against the live `ClientSession.container` because instances are
+ * created at GLSP-session-open by `McpDiagramToolHandlerRegistryInitializer`.
+ *
+ * Read-side handlers access `modelState.index` directly. Synchronous reads are atomic, but a
+ * concurrent tool that awaits `actionDispatcher.dispatch(...)` may expose a half-committed
+ * model — write-then-read tool sequences must serialize the write before the read.
+ *
+ * @experimental
+ */
+export declare abstract class BaseMcpDiagramToolHandler<T extends McpDiagramScopedInput = McpDiagramScopedInput> extends BaseMcpToolHandler {
+    protected clientId: string;
+    protected modelState: ModelState;
+    protected aliasService: McpIdAliasService;
+    protected labelProvider: McpLabelProvider;
+    /** Throw {@link McpToolError} for expected errors; the base wraps. */
+    protected abstract createResult(params: T): MaybePromise<McpToolResult>;
+    /**
+     * Public dispatch entry point invoked by {@link McpServerLauncher}'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.
+     */
+    abstract handle(params: T): Promise<McpToolResult>;
+    /** Override to opt out of registration when a runtime dependency is missing. Default: `true`. */
+    canRegister(): boolean;
+    /** Translates (alias-or-real) ids to real ids; partitions ids absent from the model into `missingIds`. */
+    protected resolveIds(ids: string[]): {
+        realIds: string[];
+        missingIds: string[];
+    };
+    /** Like {@link resolveIds} but throws {@link McpElementsNotFoundError} when any input id is absent. */
+    protected resolveExistingIds(ids: string[] | undefined): string[];
+    /**
+     * Resolves a list of structured inputs against the model: each input's id is looked up via the
+     * alias service and the resolved element is retrieved from the index. Throws
+     * {@link McpElementsNotFoundError} if any input's id is absent. The returned tuples preserve
+     * caller's input/element pairing for downstream processing (e.g. type-checks per kind).
+     */
+    protected lookupElements<I>(inputs: I[], extractId: (input: I) => string): Array<[I, GModelElement]>;
+    /** Encodes real ids to alias ids (passthrough when {@link NullMcpIdAliasService} is bound). */
+    protected encodeIds(ids: string[]): string[];
+    /**
+     * Compact identity for an element — `{ id, elementTypeId, label? }`. Mutating tools (create
+     * / modify / delete) echo this so the LLM can refer to the element by label or type in
+     * user-facing prose without a follow-up `query-elements` call. Returns `undefined` when
+     * the element is no longer in the model (e.g. just deleted).
+     */
+    protected describeElement(aliasOrRealId: string): ElementIdentity | undefined;
+    /** Describe an already-resolved {@link GModelElement} — skips the model-lookup round-trip. */
+    protected describeResolvedElement(element: GModelElement): ElementIdentity;
+}
+/**
+ * Diagram-scope tool base for **query-style** tools that read the model without mutating it
+ * (validate, get-selection, set-view, query-elements). Sibling of
+ * {@link OperationMcpDiagramToolHandler} — extend that one when the tool dispatches a
+ * model-mutating Operation.
+ *
+ * @experimental
+ */
+export declare abstract class AbstractMcpDiagramToolHandler<T extends McpDiagramScopedInput = McpDiagramScopedInput> extends BaseMcpDiagramToolHandler<T> {
+    handle(params: T): Promise<McpToolResult>;
+}
+/**
+ * Diagram-scope tool base for **operation-style** tools that mutate the model by dispatching a
+ * GLSP `Operation` (or other model-mutating `Action` like `UndoAction` / `RedoAction`) on
+ * behalf of the LLM — create, modify, delete, undo, redo. Sibling of
+ * {@link AbstractMcpDiagramToolHandler}.
+ *
+ * The base bakes in two pieces beyond the read sibling:
+ *  - `@inject(ActionDispatcher)`. Every adopter extending this base dispatches, so the
+ *    dispatcher belongs on the base, not in per-handler boilerplate.
+ *  - Throws {@link McpReadOnlyError} when `modelState.isReadonly`, surfacing a hard failure
+ *    to the LLM. The MCP-side gate is necessary even though core's `OperationActionHandler`
+ *    checks readonly itself: core's gate is a *soft* warning (returns a `MessageAction`, the
+ *    dispatch resolves successfully and the tool body would otherwise report success while
+ *    nothing changed), and `UndoRedoActionHandler` doesn't gate readonly at all.
+ *
+ * Parallels core's `OperationHandler` (sibling to `ActionHandler`, not a refinement) — but
+ * note the role flip: core's `OperationHandler` is downstream of dispatch and only needs
+ * `ModelState`; ours is upstream of dispatch (the LLM-side handler that triggers the Operation)
+ * and so additionally injects `ActionDispatcher`.
+ *
+ * @experimental
+ */
+export declare abstract class OperationMcpDiagramToolHandler<T extends McpDiagramScopedInput = McpDiagramScopedInput> extends BaseMcpDiagramToolHandler<T> {
+    protected actionDispatcher: ActionDispatcher;
+    readonly readOnlyHint = false;
+    readonly destructiveHint: boolean;
+    readonly idempotentHint: boolean;
+    handle(params: T): Promise<McpToolResult>;
+    /**
+     * Convenience for tools that initiate a `RequestAction` round-trip (rather than the
+     * fire-and-forget operation dispatch this base is named for) — wraps
+     * {@link requestActionOrFail} with `this.actionDispatcher` and a default label of
+     * `this.name`. Pass an explicit label only when the tool handles multiple distinct
+     * round-trips and wants to disambiguate them in error messages.
+     */
+    protected requestAction<R extends ResponseAction>(request: RequestAction<R>, timeoutMs: number, label?: string): Promise<R>;
+}
+/**
+ * Multi-binding identifier for diagram-scope tool handler constructors — covers both
+ * {@link AbstractMcpDiagramToolHandler} and {@link OperationMcpDiagramToolHandler}. Bound via
+ * `AbstractMcpDiagramModule.configureToolHandlers`; the per-GLSP-session registry initializer
+ * reads the list at session-open and resolves each constructor against the session container.
+ *
+ * Mirrors core's `OperationHandlerConstructor` pattern: instance fields (`readonly name = '…'`)
+ * are read off `new Constructor()` at MCP-session-init for SDK catalog registration, the same
+ * trick `bindOperations` uses to read `operationType`.
+ */
+export type McpDiagramToolHandlerConstructor = interfaces.Newable<BaseMcpDiagramToolHandler<any>>;
+export declare const McpDiagramToolHandlerConstructor: unique symbol;
+//# sourceMappingURL=mcp-tool-handler.d.ts.map

package/lib/server/mcp-tool-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tool-handler.d.ts","sourceRoot":"","sources":["../../src/server/mcp-tool-handler.ts"],"names":[],"mappings":"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"}

package/lib/server/mcp-tool-handler.js

@@ -0,0 +1,355 @@
+"use strict";
+/********************************************************************************
+ * Copyright (c) 2025-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
+ ********************************************************************************/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpDiagramToolHandlerConstructor = exports.OperationMcpDiagramToolHandler = exports.AbstractMcpDiagramToolHandler = exports.BaseMcpDiagramToolHandler = exports.AbstractMcpToolHandler = exports.BaseMcpToolHandler = exports.McpToolHandler = void 0;
+const server_1 = require("@eclipse-glsp/server");
+const inversify_1 = require("inversify");
+const mcp_handler_shared_1 = require("./mcp-handler-shared");
+const mcp_id_alias_service_1 = require("./mcp-id-alias-service");
+const mcp_label_provider_1 = require("./mcp-label-provider");
+const mcp_request_context_1 = require("./mcp-request-context");
+exports.McpToolHandler = Symbol('McpToolHandler');
+/**
+ * Shared infrastructure for both server- and diagram-scope tool handlers — exported so adopters
+ * who want to factor common helpers across server-scope and diagram-scope tools can extend a
+ * single ancestor instead of duplicating logic. Most adopters extend the more specific siblings
+ * ({@link AbstractMcpToolHandler}, {@link AbstractMcpDiagramToolHandler},
+ * {@link OperationMcpDiagramToolHandler}); reach for this base only when a helper is genuinely
+ * scope-agnostic.
+ *
+ * @experimental
+ */
+let BaseMcpToolHandler = class BaseMcpToolHandler {
+    constructor() {
+        // ─── Tool annotations (MCP spec: server/tools) ───────────────────────────────
+        // Surfaced as flat fields rather than a nested `annotations` object so adopters can
+        // override one hint with a one-line `override readonly destructiveHint = true;` instead of
+        // re-declaring the whole quartet. **Untrusted** unless from a trusted server — clients
+        // MUST treat these as advisory.
+        /**
+         * Tool does not modify its environment. Defaults to `true` here on the common base;
+         * overridden to `false` on {@link OperationMcpDiagramToolHandler} since write-style tools
+         * dispatch model-mutating operations.
+         */
+        this.readOnlyHint = true;
+        /**
+         * Tool interacts with an "open world" of external entities (web search, external APIs).
+         * Default in this codebase: `false` — diagram ops are bounded to the GLSP client. Set
+         * `true` for tools that reach off-process.
+         */
+        this.openWorldHint = false;
+    }
+    /**
+     * SDK-facing registration config; consumed by both the server-scope `registerTool` flow and
+     * the launcher's diagram-scope dispatcher. Assembles the {@link ToolAnnotations} object from
+     * the flat-field surface so adopters compose annotations via field overrides, not by
+     * redeclaring the whole annotations literal.
+     */
+    toRegistrationConfig() {
+        // `.strict()` rejects unknown keys at the SDK boundary instead of silently stripping them
+        // — turns an LLM mis-typed field name into a self-correctable JSON-RPC validation error
+        // rather than a misleading "no-op success".
+        //
+        // The `as unknown as ZodObject<ZodRawShape>` bridge is needed because `.strict()` returns
+        // a `ZodObject<…, $strict>` whose `$strict` marker generic is not assignable to the
+        // shape-only `ZodObject<ZodRawShape>` expected here. The SDK accepts both shapes
+        // structurally, so the cast is type-only — no runtime mismatch.
+        return {
+            title: this.title,
+            description: this.description,
+            inputSchema: this.inputSchema.strict(),
+            outputSchema: this.outputSchema,
+            annotations: {
+                readOnlyHint: this.readOnlyHint,
+                destructiveHint: this.destructiveHint,
+                idempotentHint: this.idempotentHint,
+                openWorldHint: this.openWorldHint
+            }
+        };
+    }
+    error(message, code) {
+        return (0, mcp_handler_shared_1.toolErrorResult)(message, code);
+    }
+    /**
+     * Convention: `message` is a short, referenceable summary (ids, types, counts); `structured`
+     * carries the full payload. The two complement rather than duplicate — balancing token usage
+     * across the heterogeneous client landscape.
+     *
+     * The MCP spec (2025-06-18) recommends mirroring `structuredContent` into a TextContent
+     * block, but in-flight discussion is softening that — `content` and `structuredContent` are
+     * increasingly model-oriented vs. machine-oriented surfaces that should be semantically
+     * equivalent, not byte-identical.
+     *
+     * Client behavior is uneven, so summary-in-content + payload-in-structured is a deliberate
+     * hedge: some clients only forward `structuredContent`, some only `content`, some forward
+     * both verbatim and double the per-call context budget.
+     *
+     * Pass `structured` whenever {@link outputSchema} is declared (the spec says clients SHOULD
+     * validate against the declared shape). Omit for plain text-only responses.
+     */
+    success(message, structured) {
+        return { isError: false, content: [{ type: 'text', text: message }], structuredContent: structured };
+    }
+    /** Catches `McpToolError` (→ `isError: true` result) and unexpected errors; tags known errors via {@link errorCodeFor}. */
+    async execute(producer) {
+        try {
+            return await producer();
+        }
+        catch (err) {
+            const code = (0, mcp_handler_shared_1.errorCodeFor)(err);
+            if (err instanceof mcp_handler_shared_1.McpToolError) {
+                return this.error(err.message, code);
+            }
+            const message = (0, mcp_handler_shared_1.extractErrorMessage)(err);
+            // Session-disposed races aren't programming errors — log at warn so they don't drown the error feed.
+            if (code === mcp_handler_shared_1.McpToolErrorCodes.SessionDisposed) {
+                this.logger.warn(`Session disposed mid-call in tool '${this.name}': ${message}`);
+            }
+            else {
+                this.logger.error(`Unexpected error in tool '${this.name}': ${message}`, err);
+            }
+            return this.error(message, code);
+        }
+    }
+};
+exports.BaseMcpToolHandler = BaseMcpToolHandler;
+__decorate([
+    (0, inversify_1.inject)(server_1.Logger),
+    __metadata("design:type", server_1.Logger)
+], BaseMcpToolHandler.prototype, "logger", void 0);
+exports.BaseMcpToolHandler = BaseMcpToolHandler = __decorate([
+    (0, inversify_1.injectable)()
+], BaseMcpToolHandler);
+/**
+ * Server-scope tool base — for tools that don't target a specific GLSP client session
+ * (e.g., listing all sessions). Bound under {@link McpToolHandler} as a server-scope singleton;
+ * the launcher invokes `registerTool(server)` once per MCP session.
+ *
+ * @experimental
+ */
+let AbstractMcpToolHandler = class AbstractMcpToolHandler extends BaseMcpToolHandler {
+    registerTool(server) {
+        server.registerTool(this.name, this.toRegistrationConfig(), async (params, extra) => mcp_request_context_1.mcpRequestContext.run(extra, () => this.execute(() => this.createResult(params))));
+    }
+};
+exports.AbstractMcpToolHandler = AbstractMcpToolHandler;
+exports.AbstractMcpToolHandler = AbstractMcpToolHandler = __decorate([
+    (0, inversify_1.injectable)()
+], AbstractMcpToolHandler);
+/**
+ * Shared per-session implementation for diagram-scope tool handlers. Adopters don't extend this
+ * directly — extend {@link AbstractMcpDiagramToolHandler} (read) or {@link OperationMcpDiagramToolHandler}
+ * (write). Exported only as the upper bound for the {@link McpDiagramToolHandlerConstructor}
+ * multi-binding.
+ *
+ * `@inject(...)` fields resolve against the live `ClientSession.container` because instances are
+ * created at GLSP-session-open by `McpDiagramToolHandlerRegistryInitializer`.
+ *
+ * Read-side handlers access `modelState.index` directly. Synchronous reads are atomic, but a
+ * concurrent tool that awaits `actionDispatcher.dispatch(...)` may expose a half-committed
+ * model — write-then-read tool sequences must serialize the write before the read.
+ *
+ * @experimental
+ */
+let BaseMcpDiagramToolHandler = class BaseMcpDiagramToolHandler extends BaseMcpToolHandler {
+    /** Override to opt out of registration when a runtime dependency is missing. Default: `true`. */
+    canRegister() {
+        return true;
+    }
+    /** Translates (alias-or-real) ids to real ids; partitions ids absent from the model into `missingIds`. */
+    resolveIds(ids) {
+        const realIds = [];
+        const missingIds = [];
+        for (const id of ids) {
+            const realId = this.aliasService.lookup(id);
+            if (this.modelState.index.find(realId)) {
+                realIds.push(realId);
+            }
+            else {
+                missingIds.push(id);
+            }
+        }
+        return { realIds, missingIds };
+    }
+    /** Like {@link resolveIds} but throws {@link McpElementsNotFoundError} when any input id is absent. */
+    resolveExistingIds(ids) {
+        if (!ids || ids.length === 0) {
+            return [];
+        }
+        const { realIds, missingIds } = this.resolveIds(ids);
+        if (missingIds.length > 0) {
+            throw new mcp_handler_shared_1.McpElementsNotFoundError(missingIds);
+        }
+        return realIds;
+    }
+    /**
+     * Resolves a list of structured inputs against the model: each input's id is looked up via the
+     * alias service and the resolved element is retrieved from the index. Throws
+     * {@link McpElementsNotFoundError} if any input's id is absent. The returned tuples preserve
+     * caller's input/element pairing for downstream processing (e.g. type-checks per kind).
+     */
+    lookupElements(inputs, extractId) {
+        const found = [];
+        const missing = [];
+        for (const input of inputs) {
+            const inputId = extractId(input);
+            const realId = this.aliasService.lookup(inputId);
+            const element = this.modelState.index.find(realId);
+            if (element) {
+                found.push([input, element]);
+            }
+            else {
+                missing.push(inputId);
+            }
+        }
+        if (missing.length > 0) {
+            throw new mcp_handler_shared_1.McpElementsNotFoundError(missing);
+        }
+        return found;
+    }
+    /** Encodes real ids to alias ids (passthrough when {@link NullMcpIdAliasService} is bound). */
+    encodeIds(ids) {
+        return ids.map(id => this.aliasService.alias(id));
+    }
+    /**
+     * Compact identity for an element — `{ id, elementTypeId, label? }`. Mutating tools (create
+     * / modify / delete) echo this so the LLM can refer to the element by label or type in
+     * user-facing prose without a follow-up `query-elements` call. Returns `undefined` when
+     * the element is no longer in the model (e.g. just deleted).
+     */
+    describeElement(aliasOrRealId) {
+        const realId = this.aliasService.lookup(aliasOrRealId);
+        const element = this.modelState.index.find(realId);
+        return element ? this.describeResolvedElement(element) : undefined;
+    }
+    /** Describe an already-resolved {@link GModelElement} — skips the model-lookup round-trip. */
+    describeResolvedElement(element) {
+        var _a;
+        const label = (_a = this.labelProvider.getLabel(element)) === null || _a === void 0 ? void 0 : _a.text;
+        // Conditional spread keeps `label` absent (not `undefined`) when the element has none —
+        // matches Zod's `.optional()` semantics so the structured payload is clean.
+        return { id: this.aliasService.alias(element.id), elementTypeId: element.type, ...(label !== undefined ? { label } : {}) };
+    }
+};
+exports.BaseMcpDiagramToolHandler = BaseMcpDiagramToolHandler;
+__decorate([
+    (0, inversify_1.inject)(server_1.ClientId),
+    __metadata("design:type", String)
+], BaseMcpDiagramToolHandler.prototype, "clientId", void 0);
+__decorate([
+    (0, inversify_1.inject)(server_1.ModelState),
+    __metadata("design:type", Object)
+], BaseMcpDiagramToolHandler.prototype, "modelState", void 0);
+__decorate([
+    (0, inversify_1.inject)(mcp_id_alias_service_1.McpIdAliasService),
+    __metadata("design:type", Object)
+], BaseMcpDiagramToolHandler.prototype, "aliasService", void 0);
+__decorate([
+    (0, inversify_1.inject)(mcp_label_provider_1.McpLabelProvider),
+    __metadata("design:type", Object)
+], BaseMcpDiagramToolHandler.prototype, "labelProvider", void 0);
+exports.BaseMcpDiagramToolHandler = BaseMcpDiagramToolHandler = __decorate([
+    (0, inversify_1.injectable)()
+], BaseMcpDiagramToolHandler);
+/**
+ * Diagram-scope tool base for **query-style** tools that read the model without mutating it
+ * (validate, get-selection, set-view, query-elements). Sibling of
+ * {@link OperationMcpDiagramToolHandler} — extend that one when the tool dispatches a
+ * model-mutating Operation.
+ *
+ * @experimental
+ */
+let AbstractMcpDiagramToolHandler = class AbstractMcpDiagramToolHandler extends BaseMcpDiagramToolHandler {
+    handle(params) {
+        return this.execute(() => this.createResult(params));
+    }
+};
+exports.AbstractMcpDiagramToolHandler = AbstractMcpDiagramToolHandler;
+exports.AbstractMcpDiagramToolHandler = AbstractMcpDiagramToolHandler = __decorate([
+    (0, inversify_1.injectable)()
+], AbstractMcpDiagramToolHandler);
+/**
+ * Diagram-scope tool base for **operation-style** tools that mutate the model by dispatching a
+ * GLSP `Operation` (or other model-mutating `Action` like `UndoAction` / `RedoAction`) on
+ * behalf of the LLM — create, modify, delete, undo, redo. Sibling of
+ * {@link AbstractMcpDiagramToolHandler}.
+ *
+ * The base bakes in two pieces beyond the read sibling:
+ *  - `@inject(ActionDispatcher)`. Every adopter extending this base dispatches, so the
+ *    dispatcher belongs on the base, not in per-handler boilerplate.
+ *  - Throws {@link McpReadOnlyError} when `modelState.isReadonly`, surfacing a hard failure
+ *    to the LLM. The MCP-side gate is necessary even though core's `OperationActionHandler`
+ *    checks readonly itself: core's gate is a *soft* warning (returns a `MessageAction`, the
+ *    dispatch resolves successfully and the tool body would otherwise report success while
+ *    nothing changed), and `UndoRedoActionHandler` doesn't gate readonly at all.
+ *
+ * Parallels core's `OperationHandler` (sibling to `ActionHandler`, not a refinement) — but
+ * note the role flip: core's `OperationHandler` is downstream of dispatch and only needs
+ * `ModelState`; ours is upstream of dispatch (the LLM-side handler that triggers the Operation)
+ * and so additionally injects `ActionDispatcher`.
+ *
+ * @experimental
+ */
+let OperationMcpDiagramToolHandler = class OperationMcpDiagramToolHandler extends BaseMcpDiagramToolHandler {
+    constructor() {
+        super(...arguments);
+        // Operation tools mutate the model — flip the read defaults. Concrete handlers override
+        // `destructiveHint` / `idempotentHint` (one line each) where it applies; the explicit `false`
+        // defaults below override the MCP spec's "true if unset" semantics so non-destructive,
+        // non-idempotent writes don't trigger overzealous client-side confirmation prompts.
+        this.readOnlyHint = false;
+        this.destructiveHint = false;
+        this.idempotentHint = false;
+    }
+    handle(params) {
+        return this.execute(() => {
+            if (this.modelState.isReadonly) {
+                throw new mcp_handler_shared_1.McpReadOnlyError();
+            }
+            return this.createResult(params);
+        });
+    }
+    /**
+     * Convenience for tools that initiate a `RequestAction` round-trip (rather than the
+     * fire-and-forget operation dispatch this base is named for) — wraps
+     * {@link requestActionOrFail} with `this.actionDispatcher` and a default label of
+     * `this.name`. Pass an explicit label only when the tool handles multiple distinct
+     * round-trips and wants to disambiguate them in error messages.
+     */
+    requestAction(request, timeoutMs, label = this.name) {
+        return (0, mcp_handler_shared_1.requestActionOrFail)(this.actionDispatcher, request, timeoutMs, label);
+    }
+};
+exports.OperationMcpDiagramToolHandler = OperationMcpDiagramToolHandler;
+__decorate([
+    (0, inversify_1.inject)(server_1.ActionDispatcher),
+    __metadata("design:type", Object)
+], OperationMcpDiagramToolHandler.prototype, "actionDispatcher", void 0);
+exports.OperationMcpDiagramToolHandler = OperationMcpDiagramToolHandler = __decorate([
+    (0, inversify_1.injectable)()
+], OperationMcpDiagramToolHandler);
+exports.McpDiagramToolHandlerConstructor = Symbol('McpDiagramToolHandlerConstructor');
+//# sourceMappingURL=mcp-tool-handler.js.map

package/lib/server/mcp-tool-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tool-handler.js","sourceRoot":"","sources":["../../src/server/mcp-tool-handler.ts"],"names":[],"mappings":"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"}