pmx-canvas 0.2.7 → 0.3.1

package/src/server/intent-registry.ts

@@ -4,7 +4,7 @@
  * Intents are EPHEMERAL PRESENCE, deliberately modelled like the attention /
  * timeline ephemerality layer rather than canvas-bound state:
  *  - an in-memory Map (NOT CanvasStateManager) — never serialized, never
- *    snapshotted, never returned by canvas_get_layout;
+ *    snapshotted, never returned by canvas_query (layout action);
  *  - count-capped (oldest evicted) and TTL-swept so a ghost can never linger;
  *  - emitted over the same workbench SSE stream as `ax-intent` /
  *    `ax-intent-clear` frames via an INJECTED emitter (server.ts wires it,
@@ -124,7 +124,7 @@ export class IntentRegistry {
 
     const now = Date.now();
     const ttl = typeof input.ttlMs === 'number' ? input.ttlMs : DEFAULT_INTENT_TTL_MS;
-    const id = input.id && this.intents.has(input.id) ? input.id : input.id ?? nextIntentId();
+    const id = input.id && this.intents.has(input.id) ? input.id : (input.id ?? nextIntentId());
     this.pruneVetoTombstones();
     if (this.vetoedIntentIds.has(id)) {
       throw new OperationError(`Intent "${id}" was vetoed. Use a new id for a revised intent.`, 409);
@@ -234,10 +234,7 @@ export class IntentRegistry {
       throw new OperationError(`No live intent "${id}" to commit.`, 409);
     }
     if (!allowedKinds.includes(intent.kind)) {
-      throw new OperationError(
-        `Intent "${id}" has kind "${intent.kind}", which cannot commit this mutation.`,
-        409,
-      );
+      throw new OperationError(`Intent "${id}" has kind "${intent.kind}", which cannot commit this mutation.`, 409);
     }
     this.committingIntentIds.add(id);
     return intent;

package/src/server/mcp-app-candidate.ts

@@ -134,16 +134,12 @@ function toSafeExternalUrl(url: string): string | null {
   return parsed.toString();
 }
 
-export function getMcpAppCandidateFromToolCompletion(
-  data: McpAppToolCompletionInput,
-): McpAppToolCandidate | null {
+export function getMcpAppCandidateFromToolCompletion(data: McpAppToolCompletionInput): McpAppToolCandidate | null {
   const inlineUrls = [
     ...(typeof data.content === 'string' ? [data.content] : []),
     ...(typeof data.detailedContent === 'string' ? [data.detailedContent] : []),
     ...collectToolResultTextFragments(data.result),
-  ].flatMap((value) =>
-    (value.match(/https?:\/\/[^\s<>"'`]+/gi) ?? []).map((url) => ({ url, keyHint: 'inline' })),
-  );
+  ].flatMap((value) => (value.match(/https?:\/\/[^\s<>"'`]+/gi) ?? []).map((url) => ({ url, keyHint: 'inline' })));
 
   const nestedUrls = collectToolResultUrlCandidates(data.result);
   const candidates = [...inlineUrls, ...nestedUrls];
@@ -156,10 +152,9 @@ export function getMcpAppCandidateFromToolCompletion(
     const safe = toSafeExternalUrl(entry.url);
     if (!safe) continue;
     const key = entry.keyHint.toLowerCase();
-    const hintedByKey =
-      /resource|resource_link|resourceurl|resource_url|app|uri|url|link|viewer|preview|canvas/.test(
-        key,
-      );
+    const hintedByKey = /resource|resource_link|resourceurl|resource_url|app|uri|url|link|viewer|preview|canvas/.test(
+      key,
+    );
     const hintedByUrl = isLikelyMcpAppWebUrl(safe);
     if (!hintedByKey && !hintedByUrl && !sourceHasMcp) continue;
     return {

package/src/server/mcp-app-host.ts

@@ -66,11 +66,7 @@ function ensureConfigDir(): void {
   }
 }
 
-const DEFAULT_MCP_APP_HOST_STATE_FILE = join(
-  PMX_CANVAS_CONFIG_DIR,
-  'workbench',
-  'mcp-app-host-state.json',
-);
+const DEFAULT_MCP_APP_HOST_STATE_FILE = join(PMX_CANVAS_CONFIG_DIR, 'workbench', 'mcp-app-host-state.json');
 
 function sessionDiagLogPath(): string {
   return String(process.env.PMX_SESSION_LOG || process.env.PMX_TEST_LOG || '').trim();
@@ -158,9 +154,7 @@ function resetRuntimeMetrics(): void {
 function clearPersistedRuntimeSessionsOnLoad(): void {
   const hadSessions = sessions.size;
   const hadMetrics =
-    metrics.hostedOpens > 0 ||
-    metrics.fallbackTotal > 0 ||
-    Object.keys(metrics.fallbackByReason).length > 0;
+    metrics.hostedOpens > 0 || metrics.fallbackTotal > 0 || Object.keys(metrics.fallbackByReason).length > 0;
   if (hadSessions === 0 && !activeSessionId && !hadMetrics) return;
 
   sessions.clear();
@@ -192,9 +186,7 @@ function ensureStateLoaded(): void {
         const normalized: McpAppHostCapability = {
           serverName: entry.serverName.trim(),
           state:
-            entry.state === 'supported' ||
-            entry.state === 'unsupported' ||
-            entry.state === 'degraded'
+            entry.state === 'supported' || entry.state === 'unsupported' || entry.state === 'degraded'
               ? entry.state
               : 'degraded',
           reasonCode:
@@ -204,9 +196,7 @@ function ensureStateLoaded(): void {
           runtimeReady: entry.runtimeReady === true,
           serverSupportsHost: entry.serverSupportsHost === true,
           updatedAt:
-            typeof entry.updatedAt === 'string' && entry.updatedAt.trim().length > 0
-              ? entry.updatedAt
-              : nowIso(),
+            typeof entry.updatedAt === 'string' && entry.updatedAt.trim().length > 0 ? entry.updatedAt : nowIso(),
         };
         capabilities.set(normalized.serverName, normalized);
       }
@@ -235,20 +225,15 @@ function ensureStateLoaded(): void {
               ? entry.state
               : 'background',
           createdAt:
-            typeof entry.createdAt === 'string' && entry.createdAt.trim().length > 0
-              ? entry.createdAt
-              : nowIso(),
+            typeof entry.createdAt === 'string' && entry.createdAt.trim().length > 0 ? entry.createdAt : nowIso(),
           lastSeenAt:
-            typeof entry.lastSeenAt === 'string' && entry.lastSeenAt.trim().length > 0
-              ? entry.lastSeenAt
-              : nowIso(),
+            typeof entry.lastSeenAt === 'string' && entry.lastSeenAt.trim().length > 0 ? entry.lastSeenAt : nowIso(),
           fallbackReason:
             typeof entry.fallbackReason === 'string' && entry.fallbackReason.trim().length > 0
               ? entry.fallbackReason
               : null,
           lastExternalOpenAt:
-            typeof entry.lastExternalOpenAt === 'string' &&
-            entry.lastExternalOpenAt.trim().length > 0
+            typeof entry.lastExternalOpenAt === 'string' && entry.lastExternalOpenAt.trim().length > 0
               ? entry.lastExternalOpenAt
               : null,
         };
@@ -268,12 +253,8 @@ function ensureStateLoaded(): void {
     if (parsed.metrics && typeof parsed.metrics === 'object') {
       const loadedHostedOpens = Number(parsed.metrics.hostedOpens ?? 0);
       const loadedFallbackTotal = Number(parsed.metrics.fallbackTotal ?? 0);
-      metrics.hostedOpens = Number.isFinite(loadedHostedOpens)
-        ? Math.max(0, Math.floor(loadedHostedOpens))
-        : 0;
-      metrics.fallbackTotal = Number.isFinite(loadedFallbackTotal)
-        ? Math.max(0, Math.floor(loadedFallbackTotal))
-        : 0;
+      metrics.hostedOpens = Number.isFinite(loadedHostedOpens) ? Math.max(0, Math.floor(loadedHostedOpens)) : 0;
+      metrics.fallbackTotal = Number.isFinite(loadedFallbackTotal) ? Math.max(0, Math.floor(loadedFallbackTotal)) : 0;
       if (parsed.metrics.fallbackByReason && typeof parsed.metrics.fallbackByReason === 'object') {
         for (const [reason, count] of Object.entries(parsed.metrics.fallbackByReason)) {
           const normalizedReason = reason.trim();
@@ -370,10 +351,9 @@ function supportsHostSessionByHint(input: McpAppCandidateInput): boolean {
   const keyHint = String(input.keyHint || '').toLowerCase();
   const inferredType = String(input.inferredType || '').toLowerCase();
 
-  const keySuggestsApps =
-    /resource|resource_link|resourceurl|resource_url|app|uri|url|link|viewer|preview|canvas/.test(
-      keyHint,
-    );
+  const keySuggestsApps = /resource|resource_link|resourceurl|resource_url|app|uri|url|link|viewer|preview|canvas/.test(
+    keyHint,
+  );
   const sourceSuggestsApps =
     sourceServer.includes('mcp') ||
     sourceServer.includes('excalidraw') ||
@@ -533,10 +513,7 @@ export function preRegisterKnownMcpAppHostCapabilities(serverNames: string[]): v
   }
 }
 
-function resolveCapabilityForCandidate(
-  input: McpAppCandidateInput,
-  trustedDomain: boolean,
-): McpAppHostCapability {
+function resolveCapabilityForCandidate(input: McpAppCandidateInput, trustedDomain: boolean): McpAppHostCapability {
   const runtimeReady = isHostRuntimeEnabled();
   const serverName = normalizeServerName(input.sourceServer);
   const serverSupportsHost = supportsHostSessionByHint(input);
@@ -645,8 +622,7 @@ function findMatchingOpenSession(input: McpAppCandidateInput): McpAppHostSession
 function registerFallback(reasonCode: string): void {
   metrics.fallbackTotal += 1;
   const normalizedReason = reasonCode.trim() || 'fallback';
-  metrics.fallbackByReason[normalizedReason] =
-    (metrics.fallbackByReason[normalizedReason] ?? 0) + 1;
+  metrics.fallbackByReason[normalizedReason] = (metrics.fallbackByReason[normalizedReason] ?? 0) + 1;
 }
 
 export function routeMcpAppCandidateToHost(input: McpAppCandidateInput): McpAppHostRoutingResult {

package/src/server/mcp-app-runtime.ts

@@ -13,15 +13,8 @@ import type {
   Tool,
 } from '@modelcontextprotocol/sdk/types.js';
 import type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import {
-  EXTENSION_ID,
-  RESOURCE_MIME_TYPE,
-} from '@modelcontextprotocol/ext-apps/server';
-import type {
-  McpUiClientCapabilities,
-  McpUiResourceCsp,
-  McpUiResourceMeta,
-} from '@modelcontextprotocol/ext-apps';
+import { EXTENSION_ID, RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
+import type { McpUiClientCapabilities, McpUiResourceCsp, McpUiResourceMeta } from '@modelcontextprotocol/ext-apps';
 import { getToolUiResourceUri } from '@modelcontextprotocol/ext-apps/app-bridge';
 import { normalizeExtAppToolResult } from './ext-app-tool-result.js';
 
@@ -39,9 +32,7 @@ export interface ExternalMcpStdioTransportConfig {
   env?: Record<string, string>;
 }
 
-export type ExternalMcpTransportConfig =
-  | ExternalMcpHttpTransportConfig
-  | ExternalMcpStdioTransportConfig;
+export type ExternalMcpTransportConfig = ExternalMcpHttpTransportConfig | ExternalMcpStdioTransportConfig;
 
 export interface OpenMcpAppInput {
   transport: ExternalMcpTransportConfig;
@@ -220,10 +211,7 @@ async function createSession(
   timeoutMs?: number,
 ): Promise<McpAppSession> {
   const transport = buildTransport(transportConfig);
-  const client = new Client(
-    { name: 'pmx-canvas-app-host', version: '0.1.0' },
-    { capabilities: clientCapabilities },
-  );
+  const client = new Client({ name: 'pmx-canvas-app-host', version: '0.1.0' }, { capabilities: clientCapabilities });
   await client.connect(transport, requestOptions(timeoutMs));
 
   const toolList = await client.listTools(undefined, requestOptions(timeoutMs));
@@ -369,10 +357,14 @@ export async function openMcpApp(input: OpenMcpAppInput): Promise<OpenMcpAppResu
     }
 
     const toolInput = isRecord(input.toolArguments) ? input.toolArguments : {};
-    const rawToolResult = await session.client.callTool({
-      name: tool.name,
-      arguments: toolInput,
-    }, undefined, options);
+    const rawToolResult = await session.client.callTool(
+      {
+        name: tool.name,
+        arguments: toolInput,
+      },
+      undefined,
+      options,
+    );
     const toolResult = normalizeExtAppToolResult({ result: rawToolResult });
     const readResult = await session.client.readResource({ uri: resourceUri }, options);
     const resourceMeta = resourceMetaFromReadResult(readResult);

package/src/server/mutation-history.ts

@@ -254,10 +254,14 @@ export function diffLayouts(
     const changes: string[] = [];
 
     if (snapNode.position.x !== curNode.position.x || snapNode.position.y !== curNode.position.y) {
-      changes.push(`moved (${snapNode.position.x},${snapNode.position.y}) → (${curNode.position.x},${curNode.position.y})`);
+      changes.push(
+        `moved (${snapNode.position.x},${snapNode.position.y}) → (${curNode.position.x},${curNode.position.y})`,
+      );
     }
     if (snapNode.size.width !== curNode.size.width || snapNode.size.height !== curNode.size.height) {
-      changes.push(`resized ${snapNode.size.width}x${snapNode.size.height} → ${curNode.size.width}x${curNode.size.height}`);
+      changes.push(
+        `resized ${snapNode.size.width}x${snapNode.size.height} → ${curNode.size.width}x${curNode.size.height}`,
+      );
     }
     if (snapNode.collapsed !== curNode.collapsed) {
       changes.push(curNode.collapsed ? 'collapsed' : 'expanded');
@@ -314,8 +318,12 @@ export function diffLayouts(
 export function formatDiff(diff: SnapshotDiffResult): string {
   const lines: string[] = [`Diff: current canvas vs snapshot "${diff.snapshotName}"`, ''];
 
-  const total = diff.addedNodes.length + diff.removedNodes.length + diff.modifiedNodes.length
-    + diff.addedEdges.length + diff.removedEdges.length;
+  const total =
+    diff.addedNodes.length +
+    diff.removedNodes.length +
+    diff.modifiedNodes.length +
+    diff.addedEdges.length +
+    diff.removedEdges.length;
 
   if (total === 0) {
     lines.push('No differences — canvas matches the snapshot exactly.');
@@ -365,7 +373,9 @@ export function formatDiff(diff: SnapshotDiffResult): string {
     lines.push('');
   }
 
-  lines.push(`Summary: +${diff.addedNodes.length} -${diff.removedNodes.length} ~${diff.modifiedNodes.length} nodes, +${diff.addedEdges.length} -${diff.removedEdges.length} edges`);
+  lines.push(
+    `Summary: +${diff.addedNodes.length} -${diff.removedNodes.length} ~${diff.modifiedNodes.length} nodes, +${diff.addedEdges.length} -${diff.removedEdges.length} edges`,
+  );
 
   return lines.join('\n');
 }

package/src/server/operations/composites.ts

@@ -9,17 +9,22 @@
  * to the standalone `canvas_add_edge` — same op, same arg mapping, same result
  * shape — by construction. No handler logic lives here.
  *
- * Migration (docs/api-stability.md + plan-006): composites land ADDITIVELY in
- * v0.2 alongside the legacy single-purpose tools (the tool surface grows, then
- * shrinks when the legacy tools are removed in v0.3). Every action here maps to a
- * registry-backed operation (plan-005 slices 1–7 + plan-008 Wave 1).
+ * Migration (docs/api-stability.md + plan-006): composites landed ADDITIVELY in
+ * v0.2 alongside the legacy single-purpose tools. As of v0.3.0 the legacy tools
+ * those composites fold are REMOVED (registration-suppressed — see
+ * `compositeFoldedOpNames` below); every action here maps to a registry-backed
+ * operation (plan-005 slices 1–7 + plan-008 Wave 1) that is now reachable ONLY
+ * through its composite (or `canvas_batch`).
  *
- * Still deferred (its legacy standalone tool keeps working; see plan-008): the
- * `canvas_snapshot` composite (the v0.3 name collision). The action enums are
- * forward-compatible: adding an action later is additive. (`canvas_webview`
- * shipped in plan-008 Wave 3 via runner injection; `canvas_app` shipped in Wave 4
- * — open-mcp-app / diagram / build-artifact. Wave 5 folded the last three legacy
- * tools deprecate-only — NO per-action input-injection mechanism was needed:
+ * Deferred to v0.4: the `canvas_snapshot` composite (still a name collision —
+ * see below). Its 6 legacy snapshot standalones (`canvas_snapshot`,
+ * `canvas_list_snapshots`, `canvas_restore`, `canvas_delete_snapshot`,
+ * `canvas_gc_snapshots`, `canvas_diff`) stay registered in v0.3.0 but are marked
+ * deprecated (description-prefixed) per docs/api-stability.md's
+ * deprecate-one-minor-before-removal rule. (`canvas_webview` shipped in plan-008
+ * Wave 3 via runner injection; `canvas_app` shipped in Wave 4 — open-mcp-app /
+ * diagram / build-artifact. Wave 5 folded the last three legacy tools
+ * deprecate-only — NO per-action input-injection mechanism was needed:
  * `canvas_add_html_node` / `canvas_add_html_primitive` → `canvas_node` action
  * "add" (type:"html" [+ primitive]); `canvas_refresh_webpage_node` → `canvas_node`
  * action "update" (refresh:true). `canvas_screenshot` stays standalone — it
@@ -30,8 +35,8 @@
  * name is ALREADY a legacy standalone tool (the save-snapshot tool, op
  * `snapshot.save`), so it cannot be added additively without a name clash, and
  * repurposing `canvas_snapshot` to be action-discriminated now would break
- * existing callers. It lands in v0.3, in the same change that removes the legacy
- * single-purpose snapshot tools and frees the name.
+ * existing callers. It lands in v0.4, in the same change that removes the 6
+ * kept-but-deprecated legacy snapshot tools and frees the name.
  *
  * This module must never import server.ts or index.ts.
  */
@@ -47,7 +52,7 @@ import { z, type ZodRawShape, type ZodTypeAny } from 'zod';
  *  - Two-discriminator (`canvas_ax_gate`, plan-007 Slice C): a `kind` × `action`
  *    matrix folds 9 ops into one tool. Set `extraDiscriminatorShape` (the `kind`
  *    enum), `memberOps` (the op names — used to derive the schema union + the
- *    deprecation notes), `actionEnum` (the action discriminator values), and
+ *    folded-op set), `actionEnum` (the action discriminator values), and
  *    `resolveOp` (maps `{ kind, action }` → op name, or undefined for an invalid
  *    combo → a loud error at dispatch). The flat `actions` map is left empty for
  *    these; the matrix path uses `resolveOp` instead.
@@ -78,8 +83,9 @@ export interface CompositeToolDefinition {
   actionEnum?: readonly string[];
   /**
    * Two-discriminator extension: every member op name. Used to build the schema
-   * union (all member-op fields, optional) and to derive a deprecation note per
-   * member op (each mapped back to its (kind, action) by `describeOp`).
+   * union (all member-op fields, optional) and to populate the folded-op set
+   * (`compositeFoldedOpNames`) that suppresses each member op's standalone
+   * registration.
    */
   memberOps?: string[];
   /**
@@ -331,36 +337,28 @@ export const compositeToolDefinitions: CompositeToolDefinition[] = [
 ];
 
 /**
- * Deprecation notes for the legacy single-purpose tools, DERIVED from the
- * composites: every operation a composite folds gets a `Deprecated: use
- * canvas_x with action "y".` prefix on its standalone tool description, steering
- * agents to the composite during the v0.2 overlap window (the legacy tools and
- * these notes are removed together in v0.3). Keyed by registry operation name.
- * Deriving it keeps the deprecation list in lockstep with the composites — a new
- * folded action automatically deprecates the tool it replaces.
+ * Operation names FOLDED by a composite, DERIVED from the composites: every op
+ * a composite folds had its standalone single-purpose tool REMOVED in v0.3.0
+ * (see docs/api-stability.md). This set is the do-not-register list —
+ * `registerOperationTools` skips any op whose name is in it, since the op is
+ * only reachable through its composite (and through `canvas_batch`) now.
+ * Deriving it from the composites keeps suppression in lockstep with them — a
+ * newly folded action is automatically suppressed from standalone registration.
  */
-export function buildCompositeDeprecationNotes(
-  definitions: CompositeToolDefinition[] = compositeToolDefinitions,
-): Map<string, string> {
-  const notes = new Map<string, string>();
+export function compositeFoldedOpNames(definitions: CompositeToolDefinition[] = compositeToolDefinitions): Set<string> {
+  const names = new Set<string>();
   for (const def of definitions) {
-    // Single-discriminator composites: one note per (action → op).
-    for (const [action, opName] of Object.entries(def.actions)) {
-      notes.set(opName, `Deprecated: use ${def.toolName} with action "${action}". `);
+    // Single-discriminator composites: the flat `actions` map values.
+    for (const opName of Object.values(def.actions)) {
+      names.add(opName);
     }
-    // Two-discriminator composites (canvas_ax_gate): one note per member op,
-    // each mapped back to its (kind, action) so the deprecation points exactly
-    // at the composite invocation that replaces the legacy tool.
-    if (def.memberOps && def.describeOp) {
+    // Two-discriminator composites (canvas_ax_gate): the explicit `memberOps`
+    // list (the flat `actions` map is empty for these).
+    if (def.memberOps) {
       for (const opName of def.memberOps) {
-        const combo = def.describeOp(opName);
-        if (!combo) continue;
-        notes.set(
-          opName,
-          `Deprecated: use ${def.toolName} with kind "${combo.kind}" action "${combo.action}". `,
-        );
+        names.add(opName);
       }
     }
   }
-  return notes;
+  return names;
 }

package/src/server/operations/http.ts

@@ -38,7 +38,8 @@ function matchPath(template: string, pathname: string): Record<string, string> |
 /**
  * Shared body reader: preserves the parsed JSON value as-is (object, array,
  * or primitive) — per-op `readInput` decides what to do with non-object
- * bodies; the shared reader never coerces.
+ * bodies; the shared reader never coerces. A non-empty body that fails to
+ * parse is a 400 (OperationError), never a silent empty input.
  */
 export async function readJsonValue(req: Request): Promise<unknown> {
   let text = '';
@@ -51,7 +52,7 @@ export async function readJsonValue(req: Request): Promise<unknown> {
   try {
     return JSON.parse(text) as unknown;
   } catch {
-    return undefined;
+    throw new OperationError('Malformed JSON body.');
   }
 }
 
@@ -68,9 +69,8 @@ async function defaultReadInput(
     return { ...query, ...params };
   }
   const body = await readJsonValue(req);
-  const record = body !== null && typeof body === 'object' && !Array.isArray(body)
-    ? body as Record<string, unknown>
-    : {};
+  const record =
+    body !== null && typeof body === 'object' && !Array.isArray(body) ? (body as Record<string, unknown>) : {};
   return { ...query, ...record, ...params };
 }
 

package/src/server/operations/index.ts

@@ -20,6 +20,9 @@ import { batchOperations } from './ops/batch.js';
 import { webviewOperations } from './ops/webview.js';
 import { appOperations } from './ops/app.js';
 import { intentOperations } from './ops/intent.js';
+import { extAppOperations } from './ops/ext-app.js';
+import { axReadOperations } from './ops/ax-read.js';
+import { canvasWireOperations } from './ops/canvas-wire.js';
 
 for (const op of [
   ...nodeOperations,
@@ -39,6 +42,9 @@ for (const op of [
   ...webviewOperations,
   ...appOperations,
   ...intentOperations,
+  ...extAppOperations,
+  ...axReadOperations,
+  ...canvasWireOperations,
 ]) {
   registerOperation(op);
 }
@@ -53,7 +59,7 @@ export {
 export { dispatchOperationRoute } from './http.js';
 export { runCanvasBatchOperation, type BatchEnvelope } from './ops/batch.js';
 // OpenMcpAppCoreResult is the SDK's cast target for executeOperation('mcpapp.open').
-export { type OpenMcpAppCoreResult } from './ops/app.js';
+export type { OpenMcpAppCoreResult } from './ops/app.js';
 export { LocalOperationInvoker, HttpOperationInvoker, type OperationInvoker } from './invoker.js';
 export { registerOperationTools, registerCompositeTools, type OperationToolHost } from './mcp.js';
 export { compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';

package/src/server/operations/invoker.ts

@@ -77,9 +77,10 @@ export class HttpOperationInvoker implements OperationInvoker {
     }
     if (!response.ok) {
       if (route.errorBodyAsResult) return parsed;
-      const message = parsed !== null && typeof parsed === 'object' && 'error' in parsed
-        ? String((parsed as { error?: unknown }).error)
-        : `HTTP ${response.status}`;
+      const message =
+        parsed !== null && typeof parsed === 'object' && 'error' in parsed
+          ? String((parsed as { error?: unknown }).error)
+          : `HTTP ${response.status}`;
       throw new OperationError(message, toOperationErrorStatus(response.status));
     }
     return parsed;

package/src/server/operations/mcp.ts

@@ -12,26 +12,24 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { getOperation, listOperations } from './registry.js';
 import type { OperationInvoker } from './invoker.js';
 import { OperationError, type OperationMcpToolHost } from './types.js';
-import { buildCompositeDeprecationNotes, compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';
+import { compositeFoldedOpNames, compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';
 
 export interface OperationToolHost extends OperationMcpToolHost {
   invoker(): OperationInvoker;
 }
 
-export function registerOperationTools(
-  server: McpServer,
-  getHost: () => Promise<OperationToolHost>,
-): void {
-  // Legacy tools folded by a composite get a "Deprecated: use canvas_x …" prefix
-  // (plan-006 step 2) so agents migrate during the v0.2 overlap window.
-  const deprecations = buildCompositeDeprecationNotes();
+export function registerOperationTools(server: McpServer, getHost: () => Promise<OperationToolHost>): void {
+  // Ops folded by a composite are NOT registered standalone: their legacy
+  // single-purpose tools were removed in v0.3.0 (docs/api-stability.md). The op
+  // itself is untouched — it stays reachable via its composite and canvas_batch.
+  const foldedOpNames = compositeFoldedOpNames();
   for (const op of listOperations()) {
+    if (foldedOpNames.has(op.name)) continue;
     const tool = op.mcp;
     if (!tool) continue;
-    const note = deprecations.get(op.name);
     server.tool(
       tool.toolName,
-      note ? note + tool.description : tool.description,
+      tool.description,
       { ...op.inputShape, ...(tool.extraShape ?? {}) },
       async (input: Record<string, unknown>) => {
         try {
@@ -190,32 +188,27 @@ export function registerCompositeTools(
   definitions: CompositeToolDefinition[] = compositeToolDefinitions,
 ): void {
   for (const def of definitions) {
-    server.tool(
-      def.toolName,
-      def.description,
-      buildCompositeShape(def),
-      async (input: Record<string, unknown>) => {
-        try {
-          const host = await getHost();
-          const opName = resolveCompositeOp(def, input);
-          const op = getOperation(opName);
-          // Strip the composite discriminators (action + any extra, e.g. `kind`)
-          // and undo any field remap; the rest is the op's raw MCP args — the same
-          // value the standalone tool would receive.
-          const rest = stripCompositeDiscriminators(def, input);
-          const opInput = op.mcp?.buildInput ? op.mcp.buildInput(rest) : rest;
-          const result = await host.invoker().invoke(opName, opInput);
-          if (op.mcp?.formatResult) {
-            return await op.mcp.formatResult(result, rest, host);
-          }
-          return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
-        } catch (error) {
-          return {
-            content: [{ type: 'text' as const, text: error instanceof Error ? error.message : String(error) }],
-            isError: true,
-          };
+    server.tool(def.toolName, def.description, buildCompositeShape(def), async (input: Record<string, unknown>) => {
+      try {
+        const host = await getHost();
+        const opName = resolveCompositeOp(def, input);
+        const op = getOperation(opName);
+        // Strip the composite discriminators (action + any extra, e.g. `kind`)
+        // and undo any field remap; the rest is the op's raw MCP args — the same
+        // value the standalone tool would receive.
+        const rest = stripCompositeDiscriminators(def, input);
+        const opInput = op.mcp?.buildInput ? op.mcp.buildInput(rest) : rest;
+        const result = await host.invoker().invoke(opName, opInput);
+        if (op.mcp?.formatResult) {
+          return await op.mcp.formatResult(result, rest, host);
         }
-      },
-    );
+        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return {
+          content: [{ type: 'text' as const, text: error instanceof Error ? error.message : String(error) }],
+          isError: true,
+        };
+      }
+    });
   }
 }