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

package/src/prompts/handlers/describe-diagram-mcp-prompt-handler.ts

@@ -0,0 +1,88 @@
+/********************************************************************************
+ * 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 { ClientSessionManager } from '@eclipse-glsp/server';
+import { inject, injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { McpPromptResult, resolveActiveSessionId } from '../../server/mcp-handler-shared';
+import { AbstractMcpPromptHandler } from '../../server/mcp-prompt-handler';
+import { CountElementsMcpToolHandler } from '../../tools/handlers/count-elements-mcp-tool-handler';
+import { DiagramModelMcpToolHandler } from '../../tools/handlers/diagram-model-mcp-tool-handler';
+import { ElementTypesMcpToolHandler } from '../../tools/handlers/element-types-mcp-tool-handler';
+import { QueryElementsMcpToolHandler } from '../../tools/handlers/query-elements-mcp-tool-handler';
+import { SetSelectionMcpToolHandler } from '../../tools/handlers/set-selection-mcp-tool-handler';
+import { SetViewMcpToolHandler } from '../../tools/handlers/set-view-mcp-tool-handler';
+
+export const DescribeDiagramArgsSchema = z.object({
+    sessionId: z
+        .string()
+        .optional()
+        .describe('GLSP client session id (open diagram). Defaults to the only open session; required when multiple are open.')
+});
+export type DescribeDiagramArgs = z.infer<typeof DescribeDiagramArgsSchema>;
+
+/**
+ * Prompt template that instructs the agent to produce a structured description of a diagram.
+ * Pre-baked starting point invokable from the MCP-client UI; the agent then orchestrates the
+ * necessary tool calls on its own.
+ *
+ * Server-scope on purpose — the prompt itself has no per-session state, so we avoid forcing
+ * the user to type a sessionId in the common single-diagram case.
+ */
+@injectable()
+export class DescribeDiagramMcpPromptHandler extends AbstractMcpPromptHandler<DescribeDiagramArgs> {
+    static readonly NAME = 'describe-diagram';
+    readonly name = DescribeDiagramMcpPromptHandler.NAME;
+    override readonly title = 'Describe Diagram';
+    readonly description =
+        'Produce a structured, skim-friendly description of an open diagram. ' +
+        'The agent picks the right tools to gather data (overview, element-type breakdown, structure, notable elements) ' +
+        'and writes the description in its own words. ' +
+        'Use this as a starting point when the user asks "what does this diagram show?" or wants a documentation-style summary. ' +
+        '`sessionId` is optional — defaults to the only open session.';
+    readonly argsSchema = DescribeDiagramArgsSchema;
+
+    @inject(ClientSessionManager) protected clientSessionManager: ClientSessionManager;
+
+    override referencedToolNames(): string[] {
+        return [
+            CountElementsMcpToolHandler.NAME,
+            ElementTypesMcpToolHandler.NAME,
+            DiagramModelMcpToolHandler.NAME,
+            QueryElementsMcpToolHandler.NAME,
+            SetSelectionMcpToolHandler.NAME,
+            SetViewMcpToolHandler.NAME
+        ];
+    }
+
+    protected createResult(args: DescribeDiagramArgs): McpPromptResult {
+        const sessionId = resolveActiveSessionId(this.clientSessionManager, args.sessionId);
+        const text =
+            `Describe the diagram for session \`${sessionId}\`. Include:\n\n` +
+            `1. **Overview** — diagram type and total element count (use \`${CountElementsMcpToolHandler.NAME}\`).\n` +
+            `2. **Element-type breakdown** — what kinds of elements are present and how many of each ` +
+            `(use \`${ElementTypesMcpToolHandler.NAME}\` and \`${CountElementsMcpToolHandler.NAME}\`).\n` +
+            `3. **Structure** — load the model with \`${DiagramModelMcpToolHandler.NAME}\` and summarize the ` +
+            `hierarchy and major connections.\n` +
+            `4. **Notable elements** — call out anything that stands out (unconnected nodes, deeply ` +
+            `nested groups, missing labels). Use \`${QueryElementsMcpToolHandler.NAME}\` to locate specific cases.\n\n` +
+            `Keep the description concise and skim-friendly. ` +
+            `When mentioning an element, prefer its label or type, with the alias appended in parens — e.g. ` +
+            `"the 'Brew' task (#7)" or "the decision node (#9)" — never the bare alias alone, since aliases mean nothing to the user. ` +
+            `Use \`${SetSelectionMcpToolHandler.NAME}\` or \`${SetViewMcpToolHandler.NAME} → 'center-on-elements'\` to draw the user's attention.`;
+        return { messages: [{ role: 'user', content: { type: 'text', text } }] };
+    }
+}

package/src/prompts/handlers/suggest-improvements-mcp-prompt-handler.ts

@@ -0,0 +1,85 @@
+/********************************************************************************
+ * 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 { ClientSessionManager } from '@eclipse-glsp/server';
+import { inject, injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { McpPromptResult, resolveActiveSessionId } from '../../server/mcp-handler-shared';
+import { AbstractMcpPromptHandler } from '../../server/mcp-prompt-handler';
+import { DiagramModelMcpToolHandler } from '../../tools/handlers/diagram-model-mcp-tool-handler';
+import { QueryElementsMcpToolHandler } from '../../tools/handlers/query-elements-mcp-tool-handler';
+import { SetSelectionMcpToolHandler } from '../../tools/handlers/set-selection-mcp-tool-handler';
+import { ValidateDiagramMcpToolHandler } from '../../tools/handlers/validate-diagram-mcp-tool-handler';
+
+export const SuggestImprovementsArgsSchema = z.object({
+    sessionId: z
+        .string()
+        .optional()
+        .describe('GLSP client session id (open diagram). Defaults to the only open session; required when multiple are open.')
+});
+export type SuggestImprovementsArgs = z.infer<typeof SuggestImprovementsArgsSchema>;
+
+/**
+ * Prompt template that asks the agent to review the diagram and propose concrete improvements
+ * (validation issues, structural smells, missing labels, etc.). The agent orchestrates the
+ * tool calls; this prompt only frames the task.
+ *
+ * Server-scope on purpose — the prompt itself has no per-session state, so we avoid forcing
+ * the user to type a sessionId in the common single-diagram case.
+ */
+@injectable()
+export class SuggestImprovementsMcpPromptHandler extends AbstractMcpPromptHandler<SuggestImprovementsArgs> {
+    static readonly NAME = 'suggest-improvements';
+    readonly name = SuggestImprovementsMcpPromptHandler.NAME;
+    override readonly title = 'Suggest Diagram Improvements';
+    readonly description =
+        'Review an open diagram and propose concrete improvements grouped by severity ' +
+        '(must-fix vs. nice-to-have). The agent runs validation, checks connectivity, looks for unclear labels, ' +
+        'and flags structural inconsistencies, then names the specific element ids for each suggestion so the user ' +
+        'can act on them. Read-only by intent — the prompt instructs the agent not to modify the diagram, only propose. ' +
+        '`sessionId` is optional — defaults to the only open session.';
+    readonly argsSchema = SuggestImprovementsArgsSchema;
+
+    @inject(ClientSessionManager) protected clientSessionManager: ClientSessionManager;
+
+    override referencedToolNames(): string[] {
+        return [
+            ValidateDiagramMcpToolHandler.NAME,
+            DiagramModelMcpToolHandler.NAME,
+            QueryElementsMcpToolHandler.NAME,
+            SetSelectionMcpToolHandler.NAME
+        ];
+    }
+
+    protected createResult(args: SuggestImprovementsArgs): McpPromptResult {
+        const sessionId = resolveActiveSessionId(this.clientSessionManager, args.sessionId);
+        const text =
+            `Review the diagram for session \`${sessionId}\` and propose concrete improvements. Focus on:\n\n` +
+            `1. **Validation issues** — run \`${ValidateDiagramMcpToolHandler.NAME}\` and surface any markers.\n` +
+            `2. **Connectivity** — load the model (\`${DiagramModelMcpToolHandler.NAME}\`) and flag unconnected ` +
+            `nodes or orphaned subgraphs.\n` +
+            `3. **Labelling** — use \`${QueryElementsMcpToolHandler.NAME}\` to find nodes that lack a meaningful ` +
+            `label, and edges with missing or unclear text.\n` +
+            `4. **Structure** — call out elements whose type or placement looks inconsistent with ` +
+            `the rest of the diagram.\n\n` +
+            `Group findings by severity (must-fix vs. nice-to-have). ` +
+            `When naming elements, prefer their label or type with the alias in parens — e.g. ` +
+            `"the 'Brew' task (#7)" or "the decision node (#9)" — never the bare alias alone, since aliases mean nothing to the user. ` +
+            `Point at each suggestion via \`${SetSelectionMcpToolHandler.NAME}\` so the user can navigate. ` +
+            `Do not modify the diagram — only propose.`;
+        return { messages: [{ role: 'user', content: { type: 'text', text } }] };
+    }
+}

package/src/resources/handlers/diagram-png-mcp-resource-handler.ts

@@ -0,0 +1,177 @@
+/********************************************************************************
+ * 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 { ClientActionKinds, isGBoundsAware, RequestExportAction } from '@eclipse-glsp/server';
+import { Role } from '@modelcontextprotocol/sdk/types.js';
+import { inject, injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { McpResourceContent, McpToolError } from '../../server/mcp-handler-shared';
+import { McpDiagramScopedInputSchema } from '../../server/mcp-input-schemas';
+import { McpMimeType } from '../../server/mcp-mime-types';
+import { McpProgressReporter } from '../../server/mcp-progress-reporter';
+import { AbstractMcpDiagramResourceHandler, McpResourceUri } from '../../server/mcp-resource-handler';
+
+export const DiagramPngInputSchema = McpDiagramScopedInputSchema.extend({
+    scale: z
+        .number()
+        .min(0.1)
+        .max(4)
+        .optional()
+        .describe(
+            "Multiplier applied to the diagram's natural extent (range 0.1..4). Use values >1 for " +
+                'sharper-than-default renders, <1 for thumbnails. Ignored when `width` or `height` is supplied.'
+        ),
+    width: z
+        .number()
+        .int()
+        .min(1)
+        .max(8192)
+        .optional()
+        .describe('Override the rendered width in pixels. When given alone, the height is derived from the diagram aspect ratio.'),
+    height: z
+        .number()
+        .int()
+        .min(1)
+        .max(8192)
+        .optional()
+        .describe('Override the rendered height in pixels. When given alone, the width is derived from the diagram aspect ratio.'),
+    timeoutMs: z
+        .number()
+        .int()
+        .min(100)
+        .max(60000)
+        .optional()
+        .describe('Override the default render timeout in milliseconds (100–60000). Useful for very large diagrams.')
+});
+export type DiagramPngInput = z.infer<typeof DiagramPngInputSchema>;
+
+/** Rendering lives on the client — `RequestExportAction('png')` routes to the registered PNG exporter, which returns base64 via `ExportResultAction`. */
+@injectable()
+export class DiagramPngMcpResourceHandler extends AbstractMcpDiagramResourceHandler<DiagramPngInput> {
+    /** Default timeout (in ms) used when the call doesn't override `timeoutMs`. Override via subclass + rebind. */
+    protected readonly defaultTimeoutMs: number = 5000;
+
+    /**
+     * Default `scale` multiplier when the caller doesn't pin `width`/`height`/`scale`. `1` means
+     * "render at the diagram's natural extent" — sharp because the client rasterises the SVG
+     * at the requested size. Adopters override (e.g. to `2` for a high-DPI deployment) via
+     * subclass + rebind.
+     */
+    protected readonly defaultScale: number = 1;
+
+    static readonly NAME = 'diagram-png';
+    readonly name = DiagramPngMcpResourceHandler.NAME;
+    override readonly title = 'Diagram Model PNG';
+    readonly description =
+        'Render the session diagram as a base64-encoded PNG screenshot of its current visible state. ' +
+        'Includes all nodes, edges, and their styling — useful when a visual answer would help the agent ' +
+        '(layout reasoning, confirming a recently-created element looks right, sharing the diagram with the user). ' +
+        "Defaults to a sharp render at the diagram's natural extent; pass `scale` to multiply, " +
+        'or `width`/`height` to pin specific dimensions. ' +
+        'Requires a connected frontend client to perform the render and is subject to a timeout if no response arrives. ' +
+        'For a structured-text view of the model use `diagram-model` instead; for vector output use `diagram-svg`.';
+    readonly mimeType: McpMimeType = 'image/png';
+    readonly uri: McpResourceUri = { template: 'glsp://diagrams/{sessionId}/png' };
+    /** Both the user (visual artifact) and the assistant (visual reasoning) consume the rendered diagram. */
+    override readonly audience: Role[] = ['user', 'assistant'];
+    /** Useful when relevant, but not always-relevant — clients may skip when text-only reasoning suffices. */
+    override readonly priority = 0.6;
+    // `lastModified` intentionally omitted: we have no cheap, accurate freshness signal for the
+    // rendered PNG (the model state doesn't track a "rendered at" timestamp), and a stale value
+    // would mislead clients.
+    override readonly toolAlternativeInputSchema = DiagramPngInputSchema;
+
+    @inject(McpProgressReporter) protected progress: McpProgressReporter;
+
+    @inject(ClientActionKinds) protected clientActionKinds: Set<string>;
+
+    /** Skip-bind when the GLSP client doesn't speak `RequestExportAction` — every read would otherwise time out. */
+    override canRegister(): boolean {
+        return this.clientActionKinds.has(RequestExportAction.KIND);
+    }
+
+    protected async createResult({ scale, width, height, timeoutMs }: DiagramPngInput): Promise<McpResourceContent> {
+        const resolved = this.resolveSize(scale, width, height);
+        // Best-effort beat for clients that opted in via `_meta.progressToken`; no-ops otherwise.
+        await this.progress.emit({ progress: 0, message: 'Awaiting client-side PNG render…' });
+        const response = await this.requestAction(
+            RequestExportAction.create('png', { formatOptions: { width: resolved.width, height: resolved.height } }),
+            timeoutMs ?? this.defaultTimeoutMs
+        );
+        // A misbehaving exporter strategy returning text-encoded data here would silently corrupt the blob; fail loudly instead.
+        if (response.encoding !== 'base64') {
+            throw new McpToolError(`PNG export returned unexpected encoding '${response.encoding}'; expected 'base64'.`);
+        }
+        return { blob: response.data };
+    }
+
+    /**
+     * Resolve the final render size with this precedence:
+     * - `width` and `height` both given → use as-is.
+     * - only one of `width`/`height` given → derive the other from the diagram aspect ratio.
+     * - neither dimension given → natural × (`scale` ?? {@link defaultScale}).
+     */
+    protected resolveSize(
+        scale: number | undefined,
+        width: number | undefined,
+        height: number | undefined
+    ): { width: number; height: number } {
+        if (width !== undefined && height !== undefined) {
+            return { width, height };
+        }
+        const natural = this.computeNaturalSize();
+        if (width !== undefined) {
+            return { width, height: Math.max(1, Math.round(width * (natural.height / natural.width))) };
+        }
+        if (height !== undefined) {
+            return { width: Math.max(1, Math.round(height * (natural.width / natural.height))), height };
+        }
+        const factor = scale ?? this.defaultScale;
+        return {
+            width: Math.max(1, Math.round(natural.width * factor)),
+            height: Math.max(1, Math.round(natural.height * factor))
+        };
+    }
+
+    /**
+     * Compute the diagram's natural extent as the bounding box of every {@link isGBoundsAware}
+     * element with both `position` and `size`. Throws when the model has no positioned elements
+     * — a 1×1 PNG of an empty diagram is technically renderable but useless, and surfacing it
+     * as a self-correctable error lets the LLM react (e.g. wait for layout, ask the user).
+     */
+    protected computeNaturalSize(): { width: number; height: number } {
+        let maxX = 0;
+        let maxY = 0;
+        for (const id of this.modelState.index.allIds()) {
+            const element = this.modelState.index.get(id);
+            if (!element || !isGBoundsAware(element)) {
+                continue;
+            }
+            const position = element.position;
+            const size = element.size;
+            if (position && size && size.width > 0 && size.height > 0) {
+                maxX = Math.max(maxX, position.x + size.width);
+                maxY = Math.max(maxY, position.y + size.height);
+            }
+        }
+        if (maxX <= 0 || maxY <= 0) {
+            throw new McpToolError(
+                'Diagram has no positioned elements yet — render once after layout completes, or pass `width` / `height` explicitly.'
+            );
+        }
+        return { width: Math.ceil(maxX), height: Math.ceil(maxY) };
+    }
+}

package/src/resources/handlers/diagram-svg-mcp-resource-handler.ts

@@ -0,0 +1,85 @@
+/********************************************************************************
+ * 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 { ClientActionKinds, RequestExportAction } from '@eclipse-glsp/server';
+import { Role } from '@modelcontextprotocol/sdk/types.js';
+import { inject, injectable } from 'inversify';
+import * as z from 'zod/v4';
+import { McpResourceContent, McpToolError } from '../../server/mcp-handler-shared';
+import { McpDiagramScopedInputSchema } from '../../server/mcp-input-schemas';
+import { McpMimeType } from '../../server/mcp-mime-types';
+import { McpProgressReporter } from '../../server/mcp-progress-reporter';
+import { AbstractMcpDiagramResourceHandler, McpResourceUri } from '../../server/mcp-resource-handler';
+
+export const DiagramSvgInputSchema = McpDiagramScopedInputSchema.extend({
+    timeoutMs: z
+        .number()
+        .int()
+        .min(100)
+        .max(60000)
+        .optional()
+        .describe('Override the default render timeout in milliseconds (100–60000). Useful for very large diagrams.')
+});
+export type DiagramSvgInput = z.infer<typeof DiagramSvgInputSchema>;
+
+/**
+ * Vector counterpart of {@link DiagramPngMcpResourceHandler}. Emits the diagram as raw SVG
+ * markup (text-encoded). No `width`/`height` knobs because SVG is vector — clients (and
+ * downstream rasterisers) scale it freely.
+ */
+@injectable()
+export class DiagramSvgMcpResourceHandler extends AbstractMcpDiagramResourceHandler<DiagramSvgInput> {
+    /** Default timeout (in ms) used when the call doesn't override `timeoutMs`. Override via subclass + rebind. */
+    protected readonly defaultTimeoutMs: number = 5000;
+
+    static readonly NAME = 'diagram-svg';
+    readonly name = DiagramSvgMcpResourceHandler.NAME;
+    override readonly title = 'Diagram Model SVG';
+    readonly description =
+        'Render the session diagram as SVG markup of its current visible state. ' +
+        'Vector format — scales without quality loss, ideal for embedding in documentation, ' +
+        'further programmatic processing, or post-export rasterisation at arbitrary resolutions. ' +
+        'Requires a connected frontend client to perform the render and is subject to a timeout if no response arrives. ' +
+        'Use `diagram-png` instead when you need a ready-to-display raster image; ' +
+        '`diagram-model` is the structured-text alternative for content-only reasoning.';
+    readonly mimeType: McpMimeType = 'image/svg+xml';
+    readonly uri: McpResourceUri = { template: 'glsp://diagrams/{sessionId}/svg' };
+    /** Both the user (visual artifact) and the assistant (visual reasoning) consume the rendered diagram. */
+    override readonly audience: Role[] = ['user', 'assistant'];
+    /** Useful when relevant, but not always-relevant — clients may skip when text-only reasoning suffices. */
+    override readonly priority = 0.6;
+    override readonly toolAlternativeInputSchema = DiagramSvgInputSchema;
+
+    @inject(McpProgressReporter) protected progress: McpProgressReporter;
+
+    @inject(ClientActionKinds) protected clientActionKinds: Set<string>;
+
+    /** Skip-bind when the GLSP client doesn't speak `RequestExportAction`. */
+    override canRegister(): boolean {
+        return this.clientActionKinds.has(RequestExportAction.KIND);
+    }
+
+    protected async createResult({ timeoutMs }: DiagramSvgInput): Promise<McpResourceContent> {
+        // Best-effort beat for clients that opted in via `_meta.progressToken`; no-ops otherwise.
+        await this.progress.emit({ progress: 0, message: 'Awaiting client-side SVG render…' });
+        const response = await this.requestAction(RequestExportAction.create('svg'), timeoutMs ?? this.defaultTimeoutMs);
+        // SVG is text-encoded — base64 encoding here would mean an exporter mis-classified its payload.
+        if (response.encoding !== 'text') {
+            throw new McpToolError(`SVG export returned unexpected encoding '${response.encoding}'; expected 'text'.`);
+        }
+        return { text: response.data };
+    }
+}

package/src/resources/services/element-types-provider.ts

@@ -0,0 +1,105 @@
+/********************************************************************************
+ * 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 { CreateEdgeOperation, CreateNodeOperation } from '@eclipse-glsp/protocol';
+import {
+    CreateEdgeOperationHandler,
+    CreateNodeOperationHandler,
+    CreateOperationHandler,
+    Logger,
+    OperationHandlerRegistry
+} from '@eclipse-glsp/server';
+import { inject, injectable } from 'inversify';
+
+/**
+ * A discoverable creatable element type emitted by the `element-types` tool handler. Adopters
+ * may add further passthrough fields beyond these — the tool handler's structured output schema
+ * is `loose()`.
+ *
+ * @experimental
+ */
+export interface ElementTypeEntry {
+    id: string;
+    /** Human-readable display name for the element TYPE (e.g. `Manual Task`). */
+    label: string;
+    /** Adopter-supplied human-readable description; absent on the default scrape impl. */
+    description?: string;
+    /** Whether create-* / modify-* tools should pass a `text` arg for this type. Absent ⇒ unknown. */
+    acceptsText?: boolean;
+}
+
+/** Node + edge types creatable in a given diagram type. */
+export interface ElementTypes {
+    nodeTypes: ElementTypeEntry[];
+    edgeTypes: ElementTypeEntry[];
+}
+
+/**
+ * Per-diagram-type provider of creatable element types. Bound on the diagram (per-GLSP-session)
+ * container so each diagram type can supply its own list. Adopters with explicit type info
+ * typically rebind to a constant-value provider; the default scrapes
+ * {@link OperationHandlerRegistry} for backwards compatibility with adopters that haven't
+ * declared their types yet.
+ *
+ * @experimental
+ */
+export interface ElementTypesProvider {
+    get(): ElementTypes;
+}
+export const ElementTypesProvider = Symbol('ElementTypesProvider');
+
+/**
+ * Default {@link ElementTypesProvider} that scrapes the per-session {@link OperationHandlerRegistry}
+ * for {@link CreateNodeOperationHandler} / {@link CreateEdgeOperationHandler} instances and reads
+ * their `elementTypeIds`.
+ */
+@injectable()
+export class DefaultElementTypesProvider implements ElementTypesProvider {
+    @inject(OperationHandlerRegistry) protected operationHandlerRegistry: OperationHandlerRegistry;
+
+    @inject(Logger) protected logger: Logger;
+
+    /** Already-warned operation types, deduped so the warn fires once per type. */
+    protected readonly warnedTypes = new Set<string>();
+
+    get(): ElementTypes {
+        const nodeTypes: ElementTypeEntry[] = [];
+        const edgeTypes: ElementTypeEntry[] = [];
+        for (const handler of this.operationHandlerRegistry.getAll()) {
+            if (CreateNodeOperationHandler.is(handler)) {
+                handler.elementTypeIds.forEach(id => nodeTypes.push({ id, label: handler.label }));
+            } else if (CreateEdgeOperationHandler.is(handler)) {
+                handler.elementTypeIds.forEach(id => edgeTypes.push({ id, label: handler.label }));
+            } else if (CreateOperationHandler.is(handler)) {
+                this.warnUnrecognizedOperationType(handler);
+            }
+        }
+        return { nodeTypes, edgeTypes };
+    }
+
+    /** Once-per-type warn when a `CreateOperationHandler` carries an unrecognized `operationType`. */
+    protected warnUnrecognizedOperationType(handler: CreateOperationHandler): void {
+        const operationType = handler.operationType;
+        if (this.warnedTypes.has(operationType)) {
+            return;
+        }
+        this.warnedTypes.add(operationType);
+        this.logger.warn(
+            `DefaultElementTypesProvider: ignoring CreateOperationHandler with operationType '${operationType}' — ` +
+                `expected '${CreateNodeOperation.KIND}' or '${CreateEdgeOperation.KIND}'. Rebind ElementTypesProvider for custom operation types.`
+        );
+    }
+}