pmx-canvas 0.2.7 → 0.3.1

package/src/server/operations/ops/annotation.ts

@@ -1,18 +1,21 @@
 /**
- * Annotation mutation op (plan-008 Wave 1): annotation.remove.
+ * Annotation ops: annotation.remove (plan-008 Wave 1) and annotation.add
+ * (plan-009 C1 slice 3 — the legacy POST /api/canvas/annotation handler,
+ * wire-identical).
  *
- * DELETE-by-id of a human-drawn canvas annotation. mutates: true → the registry
- * auto-emits one canvas-layout-update after success, matching the legacy
- * handleCanvasRemoveAnnotation handler (which emitted the layout update only on a
- * successful removal). A non-existent id is a 404 OperationError carrying the
- * exact legacy message; an omitted id is a 400 so composite callers get a loud
- * input error instead of a misleading "not found". HTTP renders errors as
- * { ok:false, error } and MCP renders them as isError tool results.
+ * annotation.remove: DELETE-by-id of a human-drawn canvas annotation.
+ * mutates: true → the registry auto-emits one canvas-layout-update after
+ * success, matching the legacy handler. A non-existent id is a 404
+ * OperationError carrying the exact legacy message; an omitted id is a 400 so
+ * composite callers get a loud input error instead of a misleading "not
+ * found". HTTP renders errors as { ok:false, error } and MCP renders them as
+ * isError tool results.
  *
  * This module must never import server.ts or index.ts.
  */
 import { z } from 'zod';
-import { canvasState } from '../../canvas-state.js';
+import { canvasState, type CanvasAnnotation } from '../../canvas-state.js';
+import { summarizeCanvasAnnotation } from '../../canvas-serialization.js';
 import { defineOperation, OperationError, type Operation } from '../types.js';
 
 const annotationRemoveShape = {
@@ -57,4 +60,113 @@ const annotationRemoveOperation = defineOperation<z.infer<typeof annotationRemov
   },
 });
 
-export const annotationOperations: Operation[] = [annotationRemoveOperation];
+// ── annotation.add (helpers moved from server.ts) ─────────────
+
+function annotationBounds(points: CanvasAnnotation['points']): CanvasAnnotation['bounds'] {
+  const xs = points.map((point) => point.x);
+  const ys = points.map((point) => point.y);
+  const minX = Math.min(...xs);
+  const minY = Math.min(...ys);
+  const maxX = Math.max(...xs);
+  const maxY = Math.max(...ys);
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+
+function textAnnotationBounds(
+  point: CanvasAnnotation['points'][number],
+  text: string,
+  width: number,
+): CanvasAnnotation['bounds'] {
+  return {
+    x: point.x,
+    y: point.y - width,
+    width: Math.max(width, text.length * width * 0.62),
+    height: width * 1.2,
+  };
+}
+
+function parseAnnotationPoints(value: unknown): CanvasAnnotation['points'] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((point) => {
+      if (!point || typeof point !== 'object' || Array.isArray(point)) return null;
+      const record = point as Record<string, unknown>;
+      if (typeof record.x !== 'number' || typeof record.y !== 'number') return null;
+      if (!Number.isFinite(record.x) || !Number.isFinite(record.y)) return null;
+      return { x: record.x, y: record.y };
+    })
+    .filter((point): point is CanvasAnnotation['points'][number] => point !== null);
+}
+
+const annotationAddShape = {
+  type: z.unknown().optional().describe("Annotation type: 'freehand' (default) or 'text'"),
+  points: z.unknown().optional().describe('Annotation points: [{ x, y }, …]'),
+  width: z.unknown().optional().describe('Stroke width (freehand) or font size (text)'),
+  color: z.unknown().optional().describe("'currentColor' or a #rrggbb hex color"),
+  label: z.unknown().optional().describe('Short annotation label'),
+  text: z.unknown().optional().describe('Text annotation content'),
+  id: z.unknown().optional().describe('Explicit annotation id'),
+};
+
+const annotationAddSchema = z.looseObject(annotationAddShape);
+
+const annotationAddOperation = defineOperation<z.infer<typeof annotationAddSchema>, Record<string, unknown>>({
+  name: 'annotation.add',
+  mutates: true,
+  input: annotationAddSchema,
+  inputShape: annotationAddShape,
+  http: {
+    method: 'POST',
+    path: '/api/canvas/annotation',
+  },
+  handler: (input) => {
+    const body: Record<string, unknown> = input;
+    const type = body.type === 'text' ? 'text' : 'freehand';
+    const points = parseAnnotationPoints(body.points);
+    if (points.length < (type === 'text' ? 1 : 2)) {
+      throw new OperationError(
+        type === 'text' ? 'Text annotation requires a valid point.' : 'Annotation requires at least two valid points.',
+      );
+    }
+
+    const defaultWidth = type === 'text' ? 24 : 4;
+    const maxWidth = type === 'text' ? 96 : 24;
+    const width =
+      typeof body.width === 'number' && Number.isFinite(body.width)
+        ? Math.min(maxWidth, Math.max(1, body.width))
+        : defaultWidth;
+    const color =
+      typeof body.color === 'string' && (body.color === 'currentColor' || /^#[0-9a-fA-F]{6}$/.test(body.color))
+        ? body.color
+        : 'currentColor';
+    const label =
+      typeof body.label === 'string' && body.label.trim().length > 0 ? body.label.trim().slice(0, 160) : undefined;
+    const text =
+      type === 'text' && typeof body.text === 'string' && body.text.trim().length > 0
+        ? body.text.trim().slice(0, 240)
+        : undefined;
+    if (type === 'text' && !text) {
+      throw new OperationError('Text annotation requires text.');
+    }
+    const id =
+      typeof body.id === 'string' && body.id.trim().length > 0
+        ? body.id.trim().slice(0, 120)
+        : `ann-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    const annotation: CanvasAnnotation = {
+      id,
+      type,
+      points,
+      bounds: type === 'text' ? textAnnotationBounds(points[0]!, text!, width) : annotationBounds(points),
+      color,
+      width,
+      ...(text ? { text } : {}),
+      ...((label ?? text) ? { label: label ?? text } : {}),
+      createdAt: new Date().toISOString(),
+    };
+
+    canvasState.addAnnotation(annotation);
+    return { ok: true, annotation: summarizeCanvasAnnotation(annotation) };
+  },
+});
+
+export const annotationOperations: Operation[] = [annotationRemoveOperation, annotationAddOperation];

package/src/server/operations/ops/app.ts

@@ -85,19 +85,16 @@ export interface OpenMcpAppCoreResult {
  * call it. The diagram.open op delegates here after building the Excalidraw input
  * (the SSE pair fires ONCE — diagram.open does not re-emit).
  */
-export async function openMcpAppCore(
-  input: OpenMcpAppCoreInput,
-  ctx: OperationContext,
-): Promise<OpenMcpAppCoreResult> {
+export async function openMcpAppCore(input: OpenMcpAppCoreInput, ctx: OperationContext): Promise<OpenMcpAppCoreResult> {
   // The canvas node is created as a side-effect of the `ext-app-open` SSE event
   // (syncEventToCanvasState). Inside a suppressed-emit run (canvas.batch) that
   // event is dropped, so the node would never be created and the just-opened
   // external session would leak with a null nodeId. Reject loudly BEFORE opening
   // any session rather than silently corrupting. mcpapp.open / diagram.open are
-  // not batchable — call canvas_open_mcp_app / canvas_add_diagram (or canvas_app).
+  // not batchable — call canvas_app (action "open-mcp-app" / "diagram") instead.
   if (isEmitSuppressed()) {
     throw new OperationError(
-      'mcpapp.open / diagram.open cannot run inside canvas_batch: the canvas node is created from the ext-app-open SSE event, which batch suppresses. Call the op directly (canvas_open_mcp_app / canvas_add_diagram, or canvas_app).',
+      'mcpapp.open / diagram.open cannot run inside canvas_batch: the canvas node is created from the ext-app-open SSE event, which batch suppresses. Call canvas_app with action "open-mcp-app" or "diagram" outside the batch.',
     );
   }
   const targetNode = input.nodeId ? canvasState.getNode(input.nodeId) : undefined;
@@ -155,10 +152,12 @@ export async function openMcpAppCore(
     success: toolResult.isError !== true,
     result: toolResult,
   });
-  const nodeId = input.nodeId ?? findCanvasExtAppNodeId(toolCallId, {
-    getNode: (id) => canvasState.getNode(id),
-    listNodes: () => canvasState.getLayout().nodes,
-  });
+  const nodeId =
+    input.nodeId ??
+    findCanvasExtAppNodeId(toolCallId, {
+      getNode: (id) => canvasState.getNode(id),
+      listNodes: () => canvasState.getLayout().nodes,
+    });
   return {
     ok: true,
     ...(nodeId ? { id: nodeId } : {}),
@@ -180,15 +179,10 @@ function buildOpenMcpAppInput(body: Record<string, unknown>): OpenMcpAppCoreInpu
     throw new OperationError('Missing valid transport or toolName.');
   }
   const toolArguments = isRecord(body.toolArguments) ? body.toolArguments : undefined;
-  const serverName = typeof body.serverName === 'string' && body.serverName.trim().length > 0
-    ? body.serverName.trim()
-    : undefined;
-  const title = typeof body.title === 'string' && body.title.trim().length > 0
-    ? body.title.trim()
-    : undefined;
-  const nodeId = typeof body.nodeId === 'string' && body.nodeId.trim().length > 0
-    ? body.nodeId.trim()
-    : undefined;
+  const serverName =
+    typeof body.serverName === 'string' && body.serverName.trim().length > 0 ? body.serverName.trim() : undefined;
+  const title = typeof body.title === 'string' && body.title.trim().length > 0 ? body.title.trim() : undefined;
+  const nodeId = typeof body.nodeId === 'string' && body.nodeId.trim().length > 0 ? body.nodeId.trim() : undefined;
   return {
     transport,
     toolName,
@@ -216,21 +210,26 @@ const openMcpAppShape = {
   y: z.number().optional().describe('Y position (auto-placed if omitted)'),
   width: z.number().optional().describe('Width in pixels (default: 720)'),
   height: z.number().optional().describe('Height in pixels (default: 500)'),
-  timeoutMs: z.number().optional().describe('Optional MCP request timeout in milliseconds for cold external app servers'),
-  transport: z.union([
-    z.object({
-      type: z.literal('stdio'),
-      command: z.string().describe('Executable used to start the external MCP server'),
-      args: z.array(z.string()).optional().describe('Arguments for the executable'),
-      cwd: z.string().optional().describe('Optional working directory'),
-      env: z.record(z.string(), z.string()).optional().describe('Optional environment overrides'),
-    }),
-    z.object({
-      type: z.literal('http'),
-      url: z.string().describe('Streamable HTTP MCP endpoint URL'),
-      headers: z.record(z.string(), z.string()).optional().describe('Optional HTTP headers'),
-    }),
-  ]).describe('How PMX Canvas should connect to the external MCP server'),
+  timeoutMs: z
+    .number()
+    .optional()
+    .describe('Optional MCP request timeout in milliseconds for cold external app servers'),
+  transport: z
+    .union([
+      z.object({
+        type: z.literal('stdio'),
+        command: z.string().describe('Executable used to start the external MCP server'),
+        args: z.array(z.string()).optional().describe('Arguments for the executable'),
+        cwd: z.string().optional().describe('Optional working directory'),
+        env: z.record(z.string(), z.string()).optional().describe('Optional environment overrides'),
+      }),
+      z.object({
+        type: z.literal('http'),
+        url: z.string().describe('Streamable HTTP MCP endpoint URL'),
+        headers: z.record(z.string(), z.string()).optional().describe('Optional HTTP headers'),
+      }),
+    ])
+    .describe('How PMX Canvas should connect to the external MCP server'),
 };
 const openMcpAppSchema = z.looseObject(openMcpAppShape);
 
@@ -246,7 +245,7 @@ const openMcpAppOperation = defineOperation<z.infer<typeof openMcpAppSchema>, Op
   mcp: {
     toolName: 'canvas_open_mcp_app',
     description:
-      'Connect to an external MCP server that declares a ui:// app resource, call the specified tool, and open the resulting MCP App inside a canvas mcp-app node. This is a full external-MCP transport call, not the CLI kind shortcut; use canvas_add_diagram for the built-in Excalidraw preset.',
+      'Connect to an external MCP server that declares a ui:// app resource, call the specified tool, and open the resulting MCP App inside a canvas mcp-app node. This is a full external-MCP transport call, not the CLI kind shortcut; use canvas_app action "diagram" for the built-in Excalidraw preset.',
     formatResult: (result) => ({
       content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
     }),
@@ -257,17 +256,29 @@ const openMcpAppOperation = defineOperation<z.infer<typeof openMcpAppSchema>, Op
 // ── diagram.open (Excalidraw preset → mcpapp.open core) ───────
 
 const diagramShape = {
-  elements: z.union([
-    z.string().describe('JSON array string of Excalidraw elements'),
-    z.array(z.record(z.string(), z.unknown())).describe('Array of Excalidraw elements'),
-  ]).describe('Excalidraw elements to render. See https://github.com/excalidraw/excalidraw-mcp for the element format.'),
-  nodeId: z.string().optional().describe('Existing Excalidraw mcp-app node ID to update in place instead of creating a new node.'),
+  elements: z
+    .union([
+      z.string().describe('JSON array string of Excalidraw elements'),
+      z.array(z.record(z.string(), z.unknown())).describe('Array of Excalidraw elements'),
+    ])
+    .describe(
+      'Excalidraw elements to render. See https://github.com/excalidraw/excalidraw-mcp for the element format.',
+    ),
+  nodeId: z
+    .string()
+    .optional()
+    .describe('Existing Excalidraw mcp-app node ID to update in place instead of creating a new node.'),
   title: z.string().optional().describe('Optional canvas node title override'),
   x: z.number().optional().describe('X position (auto-placed if omitted)'),
   y: z.number().optional().describe('Y position (auto-placed if omitted)'),
   width: z.number().optional().describe('Width in pixels (default: 720)'),
   height: z.number().optional().describe('Height in pixels (default: 500)'),
-  timeoutMs: z.number().optional().describe('Optional MCP request timeout in milliseconds for Excalidraw cold starts. Client-side MCP hosts may still enforce their own total request timeout.'),
+  timeoutMs: z
+    .number()
+    .optional()
+    .describe(
+      'Optional MCP request timeout in milliseconds for Excalidraw cold starts. Client-side MCP hosts may still enforce their own total request timeout.',
+    ),
 };
 const diagramSchema = z.looseObject(diagramShape);
 
@@ -283,13 +294,13 @@ const diagramOperation = defineOperation<z.infer<typeof diagramSchema>, OpenMcpA
   mcp: {
     toolName: 'canvas_add_diagram',
     description:
-      'Draw a hand-drawn diagram on the canvas via the hosted Excalidraw MCP app. Pass an array of Excalidraw elements (rectangles, ellipses, diamonds, arrows, text). The diagram opens inside an mcp-app node that supports fullscreen editing. For other MCP apps, use canvas_open_mcp_app.',
+      'Draw a hand-drawn diagram on the canvas via the hosted Excalidraw MCP app. Pass an array of Excalidraw elements (rectangles, ellipses, diamonds, arrows, text). The diagram opens inside an mcp-app node that supports fullscreen editing. For other MCP apps, use canvas_app action "open-mcp-app".',
     formatResult: (result) => ({
       content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }],
     }),
   },
   handler: (input, ctx) => {
-    let built;
+    let built: ReturnType<typeof buildExcalidrawOpenMcpAppInput>;
     try {
       built = buildExcalidrawOpenMcpAppInput(input);
     } catch (error) {
@@ -297,19 +308,22 @@ const diagramOperation = defineOperation<z.infer<typeof diagramSchema>, OpenMcpA
     }
     // Delegate to the shared open core (the SSE pair fires once — diagram.open
     // does not re-emit).
-    return openMcpAppCore({
-      transport: built.transport,
-      toolName: built.toolName,
-      toolArguments: built.toolArguments,
-      serverName: built.serverName,
-      ...(built.nodeId ? { nodeId: built.nodeId } : {}),
-      ...(built.title ? { title: built.title } : {}),
-      ...(typeof built.x === 'number' ? { x: built.x } : {}),
-      ...(typeof built.y === 'number' ? { y: built.y } : {}),
-      ...(typeof built.width === 'number' ? { width: built.width } : {}),
-      ...(typeof built.height === 'number' ? { height: built.height } : {}),
-      ...(typeof built.timeoutMs === 'number' ? { timeoutMs: built.timeoutMs } : {}),
-    }, ctx);
+    return openMcpAppCore(
+      {
+        transport: built.transport,
+        toolName: built.toolName,
+        toolArguments: built.toolArguments,
+        serverName: built.serverName,
+        ...(built.nodeId ? { nodeId: built.nodeId } : {}),
+        ...(built.title ? { title: built.title } : {}),
+        ...(typeof built.x === 'number' ? { x: built.x } : {}),
+        ...(typeof built.y === 'number' ? { y: built.y } : {}),
+        ...(typeof built.width === 'number' ? { width: built.width } : {}),
+        ...(typeof built.height === 'number' ? { height: built.height } : {}),
+        ...(typeof built.timeoutMs === 'number' ? { timeoutMs: built.timeoutMs } : {}),
+      },
+      ctx,
+    );
   },
 });
 
@@ -321,23 +335,42 @@ const webArtifactShape = {
   indexCss: z.string().optional().describe('Optional contents for src/index.css'),
   mainTsx: z.string().optional().describe('Optional contents for src/main.tsx'),
   indexHtml: z.string().optional().describe('Optional contents for index.html'),
-  files: z.record(z.string(), z.string()).optional().describe('Optional map of additional project-relative file paths to file contents'),
-  deps: z.array(z.string()).optional().describe('Optional npm dependencies to install before bundling (e.g. ["recharts", "framer-motion@^11"]). Validated against npm-name format; flags and shell metacharacters are rejected.'),
-  projectPath: z.string().optional().describe('Optional workspace-relative reusable project path. Defaults to .pmx-canvas/artifacts/.web-artifacts/<slug>'),
-  outputPath: z.string().optional().describe('Optional workspace-relative HTML output path. Defaults to .pmx-canvas/artifacts/<slug>.html'),
+  files: z
+    .record(z.string(), z.string())
+    .optional()
+    .describe('Optional map of additional project-relative file paths to file contents'),
+  deps: z
+    .array(z.string())
+    .optional()
+    .describe(
+      'Optional npm dependencies to install before bundling (e.g. ["recharts", "framer-motion@^11"]). Validated against npm-name format; flags and shell metacharacters are rejected.',
+    ),
+  projectPath: z
+    .string()
+    .optional()
+    .describe(
+      'Optional workspace-relative reusable project path. Defaults to .pmx-canvas/artifacts/.web-artifacts/<slug>',
+    ),
+  outputPath: z
+    .string()
+    .optional()
+    .describe('Optional workspace-relative HTML output path. Defaults to .pmx-canvas/artifacts/<slug>.html'),
   openInCanvas: z.boolean().optional().describe('Open the generated artifact in canvas after build (default true)'),
   includeLogs: z.boolean().optional().describe('Include raw build stdout/stderr in the response (default false)'),
-  initScriptPath: z.string().optional().describe('Optional script path override for tests/debugging. Must resolve inside the workspace.'),
-  bundleScriptPath: z.string().optional().describe('Optional script path override for tests/debugging. Must resolve inside the workspace.'),
+  initScriptPath: z
+    .string()
+    .optional()
+    .describe('Optional script path override for tests/debugging. Must resolve inside the workspace.'),
+  bundleScriptPath: z
+    .string()
+    .optional()
+    .describe('Optional script path override for tests/debugging. Must resolve inside the workspace.'),
   timeoutMs: z.number().optional().describe('Optional timeout in milliseconds for init and bundle commands'),
 };
 const webArtifactSchema = z.looseObject(webArtifactShape);
 
 /** Shape the byte-identical web-artifact response envelope from the build result. */
-function webArtifactEnvelope(
-  result: WebArtifactCanvasBuildResult,
-  includeLogs: boolean,
-): Record<string, unknown> {
+function webArtifactEnvelope(result: WebArtifactCanvasBuildResult, includeLogs: boolean): Record<string, unknown> {
   return {
     ok: true,
     path: result.filePath,
@@ -415,12 +448,8 @@ const webArtifactOperation = defineOperation<z.infer<typeof webArtifactSchema>,
         // legacy HTTP handler used resolveWorkspacePath; the MCP tool used its
         // own safeWorkspacePath — both enforce containment). resolveWorkspacePath
         // resolves against the active canvas workspace root.
-        ...(typeof input.projectPath === 'string'
-          ? { projectPath: resolveWorkspacePath(input.projectPath) }
-          : {}),
-        ...(typeof input.outputPath === 'string'
-          ? { outputPath: resolveWorkspacePath(input.outputPath) }
-          : {}),
+        ...(typeof input.projectPath === 'string' ? { projectPath: resolveWorkspacePath(input.projectPath) } : {}),
+        ...(typeof input.outputPath === 'string' ? { outputPath: resolveWorkspacePath(input.outputPath) } : {}),
         // Script-path overrides are honored only when contained inside the
         // workspace (enforced by resolveTrustedScriptPath in
         // executeWebArtifactBuild), so they cannot point at an arbitrary host
@@ -440,8 +469,4 @@ const webArtifactOperation = defineOperation<z.infer<typeof webArtifactSchema>,
   },
 });
 
-export const appOperations: Operation[] = [
-  openMcpAppOperation,
-  diagramOperation,
-  webArtifactOperation,
-];
+export const appOperations: Operation[] = [openMcpAppOperation, diagramOperation, webArtifactOperation];

package/src/server/operations/ops/ax-await.ts

@@ -92,7 +92,13 @@ const awaitInputSchema = z.looseObject(awaitInputShape);
 
 const awaitMcpExtraShape = {
   id: z.string(),
-  timeoutMs: z.number().int().min(0).max(120000).optional().describe('Max ms to block (default 30000; 0 = immediate read; capped at 120000).'),
+  timeoutMs: z
+    .number()
+    .int()
+    .min(0)
+    .max(120000)
+    .optional()
+    .describe('Max ms to block (default 30000; 0 = immediate read; capped at 120000).'),
 };
 
 // ── ax.approval.get (canvas_await_approval) ───────────────────
@@ -110,7 +116,8 @@ const axApprovalGetOperation = defineOperation<z.infer<typeof awaitInputSchema>,
   },
   mcp: {
     toolName: 'canvas_await_approval',
-    description: 'Block until an approval gate resolves (the human approves/rejects it in the browser) or the timeout elapses — primitive D, gates that actually gate. timeoutMs 0 = read immediately without waiting. Returns { approvalGate, pending } (pending=true → still unresolved after the wait).',
+    description:
+      'Block until an approval gate resolves (the human approves/rejects it in the browser) or the timeout elapses — primitive D, gates that actually gate. timeoutMs 0 = read immediately without waiting. Returns { approvalGate, pending } (pending=true → still unresolved after the wait).',
     extraShape: awaitMcpExtraShape,
     buildInput: buildAwaitInput,
     formatResult: (result) => {
@@ -118,7 +125,9 @@ const axApprovalGetOperation = defineOperation<z.infer<typeof awaitInputSchema>,
       const approvalGate = (body.approvalGate ?? null) as PmxAxApprovalGate | null;
       const pending = body.pending === true;
       return {
-        content: [{ type: 'text' as const, text: JSON.stringify({ ok: approvalGate !== null, approvalGate, pending }) }],
+        content: [
+          { type: 'text' as const, text: JSON.stringify({ ok: approvalGate !== null, approvalGate, pending }) },
+        ],
       };
     },
   },
@@ -148,7 +157,8 @@ const axElicitationGetOperation = defineOperation<z.infer<typeof awaitInputSchem
   },
   mcp: {
     toolName: 'canvas_await_elicitation',
-    description: 'Block until an elicitation is answered (the human responds in the browser) or the timeout elapses — primitive D. timeoutMs 0 = read immediately. Returns { elicitation, pending }.',
+    description:
+      'Block until an elicitation is answered (the human responds in the browser) or the timeout elapses — primitive D. timeoutMs 0 = read immediately. Returns { elicitation, pending }.',
     extraShape: awaitMcpExtraShape,
     buildInput: buildAwaitInput,
     formatResult: (result) => {
@@ -186,7 +196,8 @@ const axModeGetOperation = defineOperation<z.infer<typeof awaitInputSchema>, Rec
   },
   mcp: {
     toolName: 'canvas_await_mode',
-    description: 'Block until a mode request resolves (approved/rejected in the browser) or the timeout elapses — primitive D. timeoutMs 0 = read immediately. Returns { modeRequest, pending }.',
+    description:
+      'Block until a mode request resolves (approved/rejected in the browser) or the timeout elapses — primitive D. timeoutMs 0 = read immediately. Returns { modeRequest, pending }.',
     extraShape: awaitMcpExtraShape,
     buildInput: buildAwaitInput,
     formatResult: (result) => {
@@ -209,8 +220,4 @@ const axModeGetOperation = defineOperation<z.infer<typeof awaitInputSchema>, Rec
   },
 });
 
-export const axAwaitOperations: Operation[] = [
-  axApprovalGetOperation,
-  axElicitationGetOperation,
-  axModeGetOperation,
-];
+export const axAwaitOperations: Operation[] = [axApprovalGetOperation, axElicitationGetOperation, axModeGetOperation];