@vcad/mcp 0.9.4-main.47 → 0.9.4-main.48

package/README.md

@@ -6,4 +6,4 @@ vcad's MCP server as a self-contained bundle (server + BRep kernel WASM).
 { "mcpServers": { "vcad": { "command": "npx", "args": ["-y", "@vcad/mcp"] } } }
 ```
 
-Built from e8c30217ef94fd492ae13caee599b581d8334d34 at 2026-07-26T17:13:18.437Z. Source: https://github.com/ecto/vcad
+Built from fe62ea0789005cd4b3f00777274323698634167d at 2026-07-29T16:12:24.504Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -6180,22 +6180,6 @@ var init_vcad_kernel_wasm = __esm({
       resetAccumulation() {
         wasm.raytracer_resetAccumulation(this.__wbg_ptr);
       }
-      /**
-       * Set SSAO (screen-space ambient occlusion) parameters.
-       *
-       * # Arguments
-       * * `radius` - World-space hemisphere sample radius (default 0.3)
-       * * `intensity` - Occlusion strength: 0 = disabled, 1 = default (>1 stylized)
-       * * `bias` - Depth bias to prevent self-occlusion (default 0.001)
-       * * `sample_count` - Hemisphere samples per frame: 8, 16, or 32 (default 16)
-       * @param {number} radius
-       * @param {number} intensity
-       * @param {number} bias
-       * @param {number} sample_count
-       */
-      setAO(radius, intensity, bias, sample_count) {
-        wasm.raytracer_setAO(this.__wbg_ptr, radius, intensity, bias, sample_count);
-      }
       /**
        * Set the debug render mode.
        *
@@ -6251,12 +6235,6 @@ var init_vcad_kernel_wasm = __esm({
         wasm.raytracer_setEdgeStyle(this.__wbg_ptr, enable_silhouette, enable_crease, enable_boundary, silhouette_r, silhouette_g, silhouette_b, silhouette_a, crease_r, crease_g, crease_b, crease_a, boundary_r, boundary_g, boundary_b, boundary_a, silhouette_width, crease_width, boundary_width, edge_softness);
       }
       /**
-       * Set the material for all faces in the scene.
-       *
-       * # Arguments
-       * * `r`, `g`, `b` - RGB color components (0-1 range, linear)
-       * * `metallic` - Metallic factor (0 = dielectric, 1 = metal)
-       * * `roughness` - Roughness factor (0 = smooth/mirror, 1 = rough/diffuse)
        * @param {number} r
        * @param {number} g
        * @param {number} b
@@ -6269,6 +6247,57 @@ var init_vcad_kernel_wasm = __esm({
           throw takeFromExternrefTable0(ret[0]);
         }
       }
+      /**
+       * Set the material for all faces in the scene.
+       *
+       * # Arguments
+       * * `r`, `g`, `b` - RGB color components (0-1 range, linear)
+       * * `metallic` - Metallic factor (0 = dielectric, 1 = metal)
+       * * `roughness` - Roughness factor (0 = smooth/mirror, 1 = rough/diffuse)
+       * Set the material from a serialized IR `MaterialDef`.
+       *
+       * Preferred over `setMaterial`: that one only carries colour, metallic and
+       * roughness, so clearcoat, IOR and anisotropy never reached the viewport
+       * and a brushed or lacquered part shaded differently here than under
+       * `vcad-render --photoreal`. This runs the SAME derivation the CPU
+       * renderer uses (`Pbr::from_material_def`), so both agree by construction.
+       *
+       * `json` is a `MaterialDef` object; pass `null`/empty to fall back to the
+       * optional `tint` (linear RGB) or the neutral default.
+       * @param {string | null} [json]
+       * @param {Float64Array | null} [tint]
+       */
+      setMaterialFromDef(json, tint) {
+        var ptr0 = isLikeNone(json) ? 0 : passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(tint) ? 0 : passArrayF64ToWasm0(tint, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.raytracer_setMaterialFromDef(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * Set the path tracer's quality ceiling and stylisation mode.
+       *
+       * Replaces the old `setAO`. The renderer is a real path tracer now, so
+       * screen-space ambient occlusion is gone — multi-bounce GI computes
+       * contact occlusion correctly, and stacking a proxy on top of it would
+       * double-darken every concave corner.
+       *
+       * # Arguments
+       * * `max_depth` - Ceiling on path length (1 = direct lighting only,
+       *   default 6, which matches `vcad-render --photoreal`). Actual depth
+       *   escalates with accumulation, so the draft frame stays interactive
+       *   regardless of this value.
+       * * `stylize` - Draw the Sobel edge overlay. Turn this OFF for a
+       *   photoreal viewport: edge lines fight photorealism.
+       * @param {number} max_depth
+       * @param {boolean} stylize
+       */
+      setPathTrace(max_depth, stylize) {
+        wasm.raytracer_setPathTrace(this.__wbg_ptr, max_depth, stylize);
+      }
       /**
        * Set the adaptive refinement sample count.
        *
@@ -13733,10 +13762,10 @@ function isValidJWT(token, algorithm = null) {
     const tokensParts = token.split(".");
     if (tokensParts.length !== 3)
       return false;
-    const [header] = tokensParts;
-    if (!header)
+    const [header2] = tokensParts;
+    if (!header2)
       return false;
-    const parsedHeader = JSON.parse(atob(header));
+    const parsedHeader = JSON.parse(atob(header2));
     if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
       return false;
     if (!parsedHeader.alg)
@@ -18655,9 +18684,9 @@ var init_protocol = __esm({
           });
           this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
             try {
-              const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+              const { tasks: tasks2, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
               return {
-                tasks,
+                tasks: tasks2,
                 nextCursor,
                 _meta: {}
               };
@@ -18804,7 +18833,7 @@ var init_protocol = __esm({
         const capturedTransport = this._transport;
         const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
         if (handler === void 0) {
-          const errorResponse = {
+          const errorResponse2 = {
             jsonrpc: "2.0",
             id: request.id,
             error: {
@@ -18815,11 +18844,11 @@ var init_protocol = __esm({
           if (relatedTaskId && this._taskMessageQueue) {
             this._enqueueTaskMessage(relatedTaskId, {
               type: "error",
-              message: errorResponse,
+              message: errorResponse2,
               timestamp: Date.now()
             }, capturedTransport?.sessionId).catch((error2) => this._onerror(new Error(`Failed to enqueue error response: ${error2}`)));
           } else {
-            capturedTransport?.send(errorResponse).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`)));
+            capturedTransport?.send(errorResponse2).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`)));
           }
           return;
         }
@@ -18889,7 +18918,7 @@ var init_protocol = __esm({
           if (abortController.signal.aborted) {
             return;
           }
-          const errorResponse = {
+          const errorResponse2 = {
             jsonrpc: "2.0",
             id: request.id,
             error: {
@@ -18901,11 +18930,11 @@ var init_protocol = __esm({
           if (relatedTaskId && this._taskMessageQueue) {
             await this._enqueueTaskMessage(relatedTaskId, {
               type: "error",
-              message: errorResponse,
+              message: errorResponse2,
               timestamp: Date.now()
             }, capturedTransport?.sessionId);
           } else {
-            await capturedTransport?.send(errorResponse);
+            await capturedTransport?.send(errorResponse2);
           }
         }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
           if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
@@ -41040,6 +41069,18 @@ var init_CHANGELOG = __esm({
     CHANGELOG_default = {
       $schema: "./changelog.schema.json",
       entries: [
+        {
+          id: "2026-07-28-mcp-2026-07-28-protocol",
+          version: "0.9.4",
+          date: "2026-07-28",
+          category: "feat",
+          title: "MCP 2026-07-28 protocol support",
+          summary: "The vcad MCP server now fully speaks the stateless 2026-07-28 revision \u2014 server/discover, MRTR, the Tasks extension, subscriptions/listen, and streamed progress \u2014 alongside every earlier revision.",
+          features: [
+            "mcp"
+          ],
+          mcpTools: []
+        },
         {
           id: "2026-07-26-viewport-path-tracer",
           version: "0.9.4",
@@ -41073,6 +41114,21 @@ var init_CHANGELOG = __esm({
             "verify_receipt"
           ]
         },
+        {
+          id: "2026-07-26-step-export-product-anchor",
+          version: "0.9.4",
+          date: "2026-07-26",
+          category: "fix",
+          title: "STEP exports now open in external CAD",
+          summary: "Exported STEP files carry the AP214 product/representation anchor and mm units, so Shapr3D, SolidWorks, and Fusion no longer reject them as containing no 3D geometry.",
+          features: [
+            "step-export",
+            "interop"
+          ],
+          mcpTools: [
+            "export_cad"
+          ]
+        },
         {
           id: "2026-07-26-step-export-booleans",
           version: "0.9.4",
@@ -41090,6 +41146,19 @@ var init_CHANGELOG = __esm({
             "export_cad"
           ]
         },
+        {
+          id: "2026-07-26-step-analytic-circle-edges",
+          version: "0.9.4",
+          date: "2026-07-26",
+          category: "fix",
+          title: "STEP export: curved faces survive third-party import",
+          summary: "Circular edges now export as analytic CIRCLEs instead of chord polylines, so importers like Shapr3D keep cylinder walls and annular faces at the spec 1e-6 accuracy.",
+          features: [
+            "step",
+            "export",
+            "kernel"
+          ]
+        },
         {
           id: "2026-07-26-render-loon-directly",
           version: "0.9.4",
@@ -71089,7 +71158,7 @@ function listEvalTasks(args) {
   }
   const tasksDir = join3(mechevalRoot, "tasks");
   const suiteFilter = args.suite ? String(args.suite).toUpperCase() : null;
-  const tasks = [];
+  const tasks2 = [];
   for (const file of readdirSync2(tasksDir).sort()) {
     if (!file.endsWith(".json")) continue;
     try {
@@ -71097,7 +71166,7 @@ function listEvalTasks(args) {
       if (suiteFilter && String(raw.suite).toUpperCase() !== suiteFilter) {
         continue;
       }
-      tasks.push({
+      tasks2.push({
         id: raw.id,
         suite: raw.suite,
         tier: raw.tier,
@@ -71109,7 +71178,7 @@ function listEvalTasks(args) {
     } catch {
     }
   }
-  return textResult({ count: tasks.length, tasks });
+  return textResult({ count: tasks2.length, tasks: tasks2 });
 }
 async function verifyPart(args) {
   const documentId = String(args.document_id ?? "");
@@ -79908,7 +79977,7 @@ function getBuildInfo() {
   };
 }
 function buildInstructions(kernelPrompt) {
-  const header = [
+  const header2 = [
     "vcad \u2014 parametric CAD with a real BRep kernel. Coordinate system: Z-up (X right, Y forward, Z up). Units: millimeters.",
     "",
     "Workflow: `open_document` \u2192 author \u2192 see \u2192 measure \u2192 ship.",
@@ -79926,7 +79995,7 @@ function buildInstructions(kernelPrompt) {
     "",
     "PCB workflow: `create_schematic` (declare connectivity as data via `nets`) \u2192 `place_components` \u2192 `route_nets` / `add_coil` / `add_coil_array` \u2192 `run_drc` \u2192 `validate_for_fab` \u2192 `export_gerber`. All take the `document_id` from create_schematic and mutate that session \u2014 never re-send the document. `validate_for_fab` is the single 'is this board ready?' gate (DRC + renderability + Gerber serialization + blockers, all fail-closed); `export_gerber` enforces a clean DRC by default and blocks a dirty board. `board_from_solid` turns a solid part (e.g. an enclosure or stator disc in a CAD session) into an outline polygon for `place_components`. For motors, plan the winding first with `winding_layout` (slots + poles \u2192 per-coil phase/polarity/winding-factor, as data \u2014 it touches no board), then realize it with `add_coil_array`. `run_drc` returns a summary by default (counts by rule + net-pair, worst clearance, a capped sample); pass `detail:'full'` for every violation. Surgical copper edits: `get_copper` lists existing traces/vias/zones (filtered by layer/net/bbox/kind) with the same indices `delete_trace`/`delete_via`/`delete_zone` accept \u2014 discover, then delete, without exporting the document. Where two nets must touch on purpose (wye neutral, split ground, shunt tap), declare it with `add_net_tie` \u2014 prefer a region-scoped tie (position+radius) so DRC stays honest away from the junction; `delete_net_tie` takes it back."
   ].join("\n");
-  if (!kernelPrompt) return header;
+  if (!kernelPrompt) return header2;
   const sections = /* @__PURE__ */ new Map();
   for (const part of kernelPrompt.split(/^## /m).slice(1)) {
     const nl = part.indexOf("\n");
@@ -79937,7 +80006,7 @@ function buildInstructions(kernelPrompt) {
     (t2) => `## ${t2}
 ${sections.get(t2)}`
   );
-  return [header, ...picked].join("\n\n");
+  return [header2, ...picked].join("\n\n");
 }
 function parseEnvPacks() {
   const env = process.env.VCAD_MCP_PACKS?.trim();
@@ -80373,7 +80442,7 @@ async function createServer(existingEngine, context = { user: null }) {
         ]
       };
     }
-    throw new Error(`Unknown resource: ${uri}`);
+    throw new McpError(ErrorCode.InvalidParams, `Unknown resource: ${uri}`);
   });
   const clientHasInlineUi = () => {
     const caps = server.getClientCapabilities();
@@ -80787,8 +80856,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.47") {
-        return "0.9.4-main.47";
+      if ("0.9.4-main.48") {
+        return "0.9.4-main.48";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -80797,8 +80866,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "e8c30217ef94fd492ae13caee599b581d8334d34";
-    BUILD_TIME = "2026-07-26T17:13:18.437Z";
+    BUILD_SHA = "fe62ea0789005cd4b3f00777274323698634167d";
+    BUILD_TIME = "2026-07-29T16:12:24.504Z";
     SHORT_SHA = BUILD_SHA === "unknown" ? "unknown" : BUILD_SHA.slice(0, 7);
     VERSION_WITH_BUILD = SHORT_SHA === "unknown" ? PKG_VERSION : `${PKG_VERSION}+${SHORT_SHA}`;
     INSTANCE_ID = randomUUID6().slice(0, 8);
@@ -81097,18 +81166,740 @@ var init_server3 = __esm({
   }
 });
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/inMemory.js
+var InMemoryTransport;
+var init_inMemory = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/inMemory.js"() {
+    InMemoryTransport = class _InMemoryTransport {
+      constructor() {
+        this._messageQueue = [];
+      }
+      /**
+       * Creates a pair of linked in-memory transports that can communicate with each other. One should be passed to a Client and one to a Server.
+       */
+      static createLinkedPair() {
+        const clientTransport = new _InMemoryTransport();
+        const serverTransport = new _InMemoryTransport();
+        clientTransport._otherTransport = serverTransport;
+        serverTransport._otherTransport = clientTransport;
+        return [clientTransport, serverTransport];
+      }
+      async start() {
+        while (this._messageQueue.length > 0) {
+          const queuedMessage = this._messageQueue.shift();
+          this.onmessage?.(queuedMessage.message, queuedMessage.extra);
+        }
+      }
+      async close() {
+        const other = this._otherTransport;
+        this._otherTransport = void 0;
+        await other?.close();
+        this.onclose?.();
+      }
+      /**
+       * Sends a message with optional auth info.
+       * This is useful for testing authentication scenarios.
+       */
+      async send(message, options) {
+        if (!this._otherTransport) {
+          throw new Error("Not connected");
+        }
+        if (this._otherTransport.onmessage) {
+          this._otherTransport.onmessage(message, { authInfo: options?.authInfo });
+        } else {
+          this._otherTransport._messageQueue.push({ message, extra: { authInfo: options?.authInfo } });
+        }
+      }
+    };
+  }
+});
+
+// src/protocol-2026.ts
+import { EventEmitter } from "node:events";
+import { randomUUID as randomUUID7 } from "node:crypto";
+function header(headers, name) {
+  if (!headers) return void 0;
+  const lower = name.toLowerCase();
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() !== lower) continue;
+    return Array.isArray(v) ? v[0] : v;
+  }
+  return void 0;
+}
+function metaOf(msg) {
+  const params = msg?.params;
+  const meta = params?._meta;
+  return meta && typeof meta === "object" ? meta : void 0;
+}
+function isModernMessage(msg, headers) {
+  const first = Array.isArray(msg) ? msg[0] : msg;
+  if (!first || typeof first !== "object") return false;
+  const method = first.method;
+  if (typeof method === "string" && MODERN_ONLY_METHODS.has(method)) return true;
+  const declared = metaOf(first)?.[META_PROTOCOL_VERSION];
+  if (typeof declared === "string") return true;
+  return header(headers, "mcp-method") !== void 0;
+}
+function decodeHeaderValue(value) {
+  if (!value.startsWith(BASE64_SENTINEL_PREFIX) || !value.endsWith(BASE64_SENTINEL_SUFFIX) || value.length < BASE64_SENTINEL_PREFIX.length + BASE64_SENTINEL_SUFFIX.length) {
+    return value;
+  }
+  const encoded = value.slice(
+    BASE64_SENTINEL_PREFIX.length,
+    value.length - BASE64_SENTINEL_SUFFIX.length
+  );
+  try {
+    return Buffer.from(encoded, "base64").toString("utf-8");
+  } catch {
+    return value;
+  }
+}
+function errorResponse(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: data === void 0 ? { code, message } : { code, message, data }
+  };
+}
+function unsupportedVersion(id, requested) {
+  return {
+    status: 400,
+    body: errorResponse(
+      id,
+      ERR_UNSUPPORTED_PROTOCOL_VERSION,
+      "Unsupported protocol version",
+      { supported: SUPPORTED_PROTOCOL_VERSIONS2, requested }
+    )
+  };
+}
+function headerMismatch(id, message) {
+  return {
+    status: 400,
+    body: errorResponse(id, ERR_HEADER_MISMATCH, `Header mismatch: ${message}`)
+  };
+}
+function pruneTasks() {
+  const now = Date.now();
+  for (const [id, t2] of tasks) {
+    if (t2.expiresAt <= now) {
+      t2.dispose?.();
+      tasks.delete(id);
+    }
+  }
+}
+function touchTask(t2, status, message) {
+  if (status) t2.status = status;
+  if (message !== void 0) t2.statusMessage = message;
+  t2.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  bus.emit(EVT_TASK, detailedTask(t2));
+}
+function detailedTask(t2) {
+  const base = {
+    taskId: t2.taskId,
+    status: t2.status,
+    createdAt: t2.createdAt,
+    lastUpdatedAt: t2.lastUpdatedAt,
+    ttlMs: TASK_TTL_MS,
+    pollIntervalMs: TASK_POLL_INTERVAL_MS
+  };
+  if (t2.statusMessage !== void 0) base.statusMessage = t2.statusMessage;
+  if (t2.status === "input_required") base.inputRequests = t2.inputRequests;
+  if (t2.status === "completed") base.result = t2.result ?? {};
+  if (t2.status === "failed") base.error = t2.error ?? { code: ERR_INTERNAL, message: "unknown" };
+  return base;
+}
+async function openBridge(createServer2, clientInfo, clientCapabilities, hooks) {
+  const [clientSide, serverSide] = InMemoryTransport.createLinkedPair();
+  let nextId3 = 1;
+  const pending2 = /* @__PURE__ */ new Map();
+  clientSide.onmessage = (msg) => {
+    const m = msg;
+    const id = m.id;
+    if (id !== void 0 && ("result" in m || "error" in m)) {
+      pending2.get(id)?.(m);
+      pending2.delete(id);
+      return;
+    }
+    if (id !== void 0 && typeof m.method === "string") {
+      void hooks.onServerRequest(
+        m.method,
+        m.params ?? {}
+      ).then(
+        (result) => clientSide.send({ jsonrpc: "2.0", id, result })
+      ).catch(
+        () => clientSide.send({
+          jsonrpc: "2.0",
+          id,
+          error: { code: ERR_INTERNAL, message: "input bridge failed" }
+        })
+      );
+      return;
+    }
+    if (typeof m.method === "string" && id === void 0) {
+      hooks.onNotification?.(m);
+    }
+  };
+  await clientSide.start();
+  const server = await createServer2();
+  await server.connect(serverSide);
+  const rpc = (method, params) => {
+    const id = nextId3++;
+    return new Promise((resolve5) => {
+      pending2.set(id, (m) => resolve5(m));
+      void clientSide.send({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params: params ?? {}
+      });
+    });
+  };
+  const init2 = await rpc("initialize", {
+    protocolVersion: BRIDGE_VERSION,
+    capabilities: clientCapabilities,
+    clientInfo
+  });
+  await clientSide.send({
+    jsonrpc: "2.0",
+    method: "notifications/initialized"
+  });
+  return {
+    rpc,
+    handshake: init2.result ?? {},
+    close: async () => {
+      pending2.clear();
+      await server.close().catch(() => {
+      });
+      await clientSide.close().catch(() => {
+      });
+    }
+  };
+}
+async function handleModernRequest(msg, opts) {
+  if (Array.isArray(msg)) {
+    return {
+      status: 400,
+      body: errorResponse(
+        null,
+        ERR_INVALID_PARAMS,
+        "Batched requests are not supported; send one JSON-RPC message per POST"
+      )
+    };
+  }
+  if (!msg || typeof msg !== "object") {
+    return {
+      status: 400,
+      body: errorResponse(null, ERR_INVALID_PARAMS, "Malformed JSON-RPC message")
+    };
+  }
+  const req = msg;
+  const id = req.id;
+  const method = req.method;
+  const params = req.params ?? {};
+  const meta = metaOf(req) ?? {};
+  if (id === void 0 || id === null) return { status: 202, body: null };
+  if (typeof method !== "string") {
+    return {
+      status: 400,
+      body: errorResponse(id, ERR_INVALID_PARAMS, "Missing JSON-RPC method")
+    };
+  }
+  const bodyVersion = meta[META_PROTOCOL_VERSION];
+  const headerVersion = header(opts.headers, "mcp-protocol-version");
+  if (typeof bodyVersion === "string" && headerVersion !== void 0 && headerVersion !== bodyVersion) {
+    return headerMismatch(
+      id,
+      `MCP-Protocol-Version header value '${headerVersion}' does not match body value '${bodyVersion}'`
+    );
+  }
+  const version2 = typeof bodyVersion === "string" ? bodyVersion : headerVersion;
+  if (version2 === void 0) {
+    if (method !== "server/discover") {
+      return unsupportedVersion(id, "(unspecified)");
+    }
+  } else if (version2 !== PROTOCOL_2026) {
+    return unsupportedVersion(id, version2);
+  }
+  if (opts.headers) {
+    const methodHeader = header(opts.headers, "mcp-method");
+    if (methodHeader === void 0) {
+      return headerMismatch(id, "required header Mcp-Method is missing");
+    }
+    if (methodHeader !== method) {
+      return headerMismatch(
+        id,
+        `Mcp-Method header value '${methodHeader}' does not match body value '${method}'`
+      );
+    }
+    const expectedName = NAME_HEADER_METHODS.has(method) ? params.name : method === "resources/read" ? params.uri : void 0;
+    if (typeof expectedName === "string") {
+      const nameHeader = header(opts.headers, "mcp-name");
+      if (nameHeader === void 0) {
+        return headerMismatch(id, "required header Mcp-Name is missing");
+      }
+      if (decodeHeaderValue(nameHeader) !== expectedName) {
+        return headerMismatch(
+          id,
+          `Mcp-Name header value does not match body value '${expectedName}'`
+        );
+      }
+    }
+  }
+  if (method === "tasks/get" || method === "tasks/update" || method === "tasks/cancel") {
+    return handleTaskMethod(id, method, params);
+  }
+  if (method === "initialize") {
+    return {
+      status: 404,
+      body: errorResponse(
+        id,
+        ERR_METHOD_NOT_FOUND,
+        `'initialize' was removed in protocol ${PROTOCOL_2026}; use 'server/discover'. This server supports: ${SUPPORTED_PROTOCOL_VERSIONS2.join(", ")}`
+      )
+    };
+  }
+  if (method !== "server/discover" && !FORWARDED_METHODS.has(method)) {
+    return {
+      status: 404,
+      body: errorResponse(id, ERR_METHOD_NOT_FOUND, `Unknown method '${method}'`)
+    };
+  }
+  const rawClientInfo = meta[META_CLIENT_INFO];
+  const infoObj = rawClientInfo && typeof rawClientInfo === "object" ? rawClientInfo : {};
+  const clientInfo = {
+    name: typeof infoObj.name === "string" ? infoObj.name : "unknown",
+    version: typeof infoObj.version === "string" ? infoObj.version : "0.0.0"
+  };
+  const rawCaps = meta[META_CLIENT_CAPABILITIES];
+  const clientCapabilities = rawCaps && typeof rawCaps === "object" ? rawCaps : {};
+  const wantsLogs = typeof meta[META_LOG_LEVEL] === "string";
+  const inputResponses = params.inputResponses && typeof params.inputResponses === "object" ? params.inputResponses : {};
+  const extCaps = clientCapabilities.extensions ?? {};
+  const asTask = method === "tools/call" && TASKS_EXTENSION in extCaps && typeof params.name === "string" && LONG_RUNNING_TOOLS.has(params.name);
+  let inputSeq = 0;
+  const capturedInputRequests = {};
+  const onServerRequest = async (reqMethod, reqParams) => {
+    if (reqMethod !== "elicitation/create") {
+      throw new Error(`unsupported server-initiated request ${reqMethod}`);
+    }
+    if (bridgeRef) {
+      const parked = taskElicitation(bridgeRef, reqParams);
+      if (parked) return parked;
+    }
+    const key = `input_${++inputSeq}`;
+    const provided = inputResponses[key];
+    if (provided) return provided;
+    if (!MRTR_METHODS.has(method)) return { action: "cancel" };
+    const { elicitationId: _drop, ...cleanParams } = reqParams;
+    capturedInputRequests[key] = {
+      method: "elicitation/create",
+      params: cleanParams
+    };
+    return { action: "cancel" };
+  };
+  let bridge;
+  let bridgeRef;
+  try {
+    bridge = bridgeRef = await openBridge(opts.createServer, clientInfo, clientCapabilities, {
+      onNotification: (n) => {
+        const nm = n.method;
+        if (nm === "notifications/message" && !wantsLogs) return;
+        opts.onNotification?.(n);
+      },
+      onServerRequest
+    });
+    if (method === "server/discover") {
+      const info = bridge.handshake;
+      const capabilities = { ...info.capabilities ?? {} };
+      capabilities.extensions = {
+        ...capabilities.extensions ?? {},
+        [TASKS_EXTENSION]: {}
+      };
+      const result2 = {
+        resultType: "complete",
+        supportedVersions: SUPPORTED_PROTOCOL_VERSIONS2,
+        capabilities,
+        _meta: { [META_SERVER_INFO]: info.serverInfo ?? {} }
+      };
+      if (info.instructions) result2.instructions = info.instructions;
+      decorateCache(result2, "server/discover");
+      return { status: 200, body: { jsonrpc: "2.0", id, result: result2 } };
+    }
+    const serverInfo = bridge.handshake.serverInfo ?? {
+      name: "vcad",
+      version: "0.0.0"
+    };
+    const forwarded = stripModernFields(params);
+    if (asTask) {
+      pruneTasks();
+      const record2 = createTaskRecord(params.name);
+      const owned = bridge;
+      bridge = void 0;
+      runTaskInBackground(record2, owned, method, forwarded, inputResponses);
+      const result2 = {
+        resultType: "task",
+        ...detailedTask(record2),
+        _meta: { [META_SERVER_INFO]: serverInfo }
+      };
+      return { status: 200, body: { jsonrpc: "2.0", id, result: result2 } };
+    }
+    const reply = await bridge.rpc(method, forwarded);
+    if (Object.keys(capturedInputRequests).length > 0) {
+      const result2 = {
+        resultType: "input_required",
+        inputRequests: capturedInputRequests,
+        _meta: { [META_SERVER_INFO]: serverInfo }
+      };
+      return { status: 200, body: { jsonrpc: "2.0", id, result: result2 } };
+    }
+    if (reply.error) {
+      const code = reply.error.code === LEGACY_RESOURCE_NOT_FOUND ? ERR_INVALID_PARAMS : reply.error.code;
+      return {
+        status: code === ERR_METHOD_NOT_FOUND ? 404 : 200,
+        body: errorResponse(id, code, reply.error.message, reply.error.data)
+      };
+    }
+    const result = { ...reply.result ?? {} };
+    result.resultType = "complete";
+    const resultMeta = result._meta && typeof result._meta === "object" ? { ...result._meta } : {};
+    resultMeta[META_SERVER_INFO] = serverInfo;
+    result._meta = resultMeta;
+    decorateCache(result, method);
+    if (method === "tools/call" && params.name === "set_tool_packs") {
+      bus.emit(EVT_TOOLS_CHANGED);
+    }
+    return { status: 200, body: { jsonrpc: "2.0", id, result } };
+  } catch (err7) {
+    return {
+      status: 500,
+      body: errorResponse(
+        id,
+        ERR_INTERNAL,
+        err7 instanceof Error ? err7.message : String(err7)
+      )
+    };
+  } finally {
+    await bridge?.close();
+  }
+}
+function decorateCache(result, method) {
+  const ttl = CACHEABLE_METHODS.get(method);
+  if (ttl === void 0) return;
+  result.ttlMs = ttl;
+  result.cacheScope = CACHE_SCOPE;
+}
+function stripModernFields(params) {
+  const out = { ...params };
+  delete out.inputResponses;
+  delete out.requestState;
+  const meta = out._meta;
+  if (meta && typeof meta === "object") {
+    const rest = { ...meta };
+    delete rest[META_PROTOCOL_VERSION];
+    delete rest[META_CLIENT_CAPABILITIES];
+    delete rest[META_CLIENT_INFO];
+    delete rest[META_LOG_LEVEL];
+    if (Object.keys(rest).length === 0) delete out._meta;
+    else out._meta = rest;
+  }
+  return out;
+}
+function createTaskRecord(toolName) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record2 = {
+    taskId: `task_${randomUUID7().slice(0, 13)}`,
+    status: "working",
+    statusMessage: `running ${toolName}`,
+    createdAt: now,
+    lastUpdatedAt: now,
+    expiresAt: Date.now() + TASK_TTL_MS,
+    toolName,
+    inputRequests: {},
+    pendingInputs: /* @__PURE__ */ new Map(),
+    cancelRequested: false
+  };
+  tasks.set(record2.taskId, record2);
+  return record2;
+}
+function runTaskInBackground(record2, bridge, method, forwarded, presetResponses) {
+  record2.dispose = () => {
+    void bridge.close();
+  };
+  taskInputHooks.set(bridge, { record: record2, presetResponses, seq: 0 });
+  void bridge.rpc(method, forwarded).then((reply) => {
+    if (record2.status === "cancelled") return;
+    if (reply.error) {
+      record2.error = reply.error;
+      touchTask(record2, "failed", reply.error.message);
+    } else {
+      const result = { ...reply.result ?? {} };
+      result.resultType = "complete";
+      record2.result = result;
+      touchTask(record2, "completed", `${record2.toolName} finished`);
+    }
+  }).catch((err7) => {
+    record2.error = {
+      code: ERR_INTERNAL,
+      message: err7 instanceof Error ? err7.message : String(err7)
+    };
+    touchTask(record2, "failed");
+  }).finally(() => {
+    taskInputHooks.delete(bridge);
+    void bridge.close();
+    record2.dispose = void 0;
+  });
+}
+function taskElicitation(bridge, reqParams) {
+  const ctx = taskInputHooks.get(bridge);
+  if (!ctx) return void 0;
+  const { record: record2, presetResponses } = ctx;
+  const key = `input_${++ctx.seq}`;
+  const preset = presetResponses[key];
+  if (preset) return Promise.resolve(preset);
+  if (record2.cancelRequested) return Promise.resolve({ action: "cancel" });
+  const { elicitationId: _drop, ...cleanParams } = reqParams;
+  record2.inputRequests[key] = {
+    method: "elicitation/create",
+    params: cleanParams
+  };
+  return new Promise((resolve5) => {
+    record2.pendingInputs.set(key, resolve5);
+    touchTask(record2, "input_required", "waiting for client input");
+  });
+}
+function handleTaskMethod(id, method, params) {
+  pruneTasks();
+  const taskId = typeof params.taskId === "string" ? params.taskId : "";
+  const record2 = tasks.get(taskId);
+  if (!record2) {
+    return {
+      status: 200,
+      body: errorResponse(
+        id,
+        ERR_INVALID_PARAMS,
+        `Unknown taskId '${taskId}' \u2014 expired, cancelled long ago, or from a previous server instance`
+      )
+    };
+  }
+  if (method === "tasks/get") {
+    const result = { resultType: "complete", ...detailedTask(record2) };
+    return { status: 200, body: { jsonrpc: "2.0", id, result } };
+  }
+  if (method === "tasks/update") {
+    const responses = params.inputResponses && typeof params.inputResponses === "object" ? params.inputResponses : {};
+    for (const [key, response] of Object.entries(responses)) {
+      const resolve5 = record2.pendingInputs.get(key);
+      if (!resolve5) continue;
+      record2.pendingInputs.delete(key);
+      delete record2.inputRequests[key];
+      resolve5(response);
+    }
+    if (record2.status === "input_required" && Object.keys(record2.inputRequests).length === 0) {
+      touchTask(record2, "working", `running ${record2.toolName}`);
+    }
+    return {
+      status: 200,
+      body: { jsonrpc: "2.0", id, result: { resultType: "complete" } }
+    };
+  }
+  record2.cancelRequested = true;
+  if (record2.status === "working" || record2.status === "input_required") {
+    for (const [key, resolve5] of record2.pendingInputs) {
+      record2.pendingInputs.delete(key);
+      delete record2.inputRequests[key];
+      resolve5({ action: "cancel" });
+    }
+    touchTask(record2, "cancelled", "cancelled by client");
+  }
+  return {
+    status: 200,
+    body: { jsonrpc: "2.0", id, result: { resultType: "complete" } }
+  };
+}
+function handleModernListen(msg, sink) {
+  const req = msg;
+  const subscriptionId = req.id ?? null;
+  const filter = req.params?.notifications && typeof req.params.notifications === "object" ? req.params.notifications : {};
+  const honored = {};
+  const listeners = [];
+  if (filter.toolsListChanged === true) {
+    honored.toolsListChanged = true;
+    const onChange = () => sink.send({
+      jsonrpc: "2.0",
+      method: "notifications/tools/list_changed",
+      params: { _meta: { [META_SUBSCRIPTION_ID]: subscriptionId } }
+    });
+    bus.on(EVT_TOOLS_CHANGED, onChange);
+    listeners.push(() => bus.off(EVT_TOOLS_CHANGED, onChange));
+  }
+  const taskIds = Array.isArray(filter.taskIds) ? filter.taskIds.filter((t2) => typeof t2 === "string") : [];
+  if (taskIds.length > 0) {
+    honored.taskIds = taskIds;
+    const wanted = new Set(taskIds);
+    const onTask = (task) => {
+      if (!wanted.has(task.taskId)) return;
+      sink.send({
+        jsonrpc: "2.0",
+        method: "notifications/tasks",
+        params: { _meta: { [META_SUBSCRIPTION_ID]: subscriptionId }, ...task }
+      });
+    };
+    bus.on(EVT_TASK, onTask);
+    listeners.push(() => bus.off(EVT_TASK, onTask));
+  }
+  sink.send({
+    jsonrpc: "2.0",
+    method: "notifications/subscriptions/acknowledged",
+    params: {
+      _meta: { [META_SUBSCRIPTION_ID]: subscriptionId },
+      notifications: honored
+    }
+  });
+  return {
+    close: () => {
+      for (const off of listeners) off();
+      listeners.length = 0;
+    }
+  };
+}
+var PROTOCOL_2026, BRIDGE_VERSION, SUPPORTED_PROTOCOL_VERSIONS2, META_PROTOCOL_VERSION, META_CLIENT_CAPABILITIES, META_CLIENT_INFO, META_SERVER_INFO, META_LOG_LEVEL, META_SUBSCRIPTION_ID, TASKS_EXTENSION, ERR_HEADER_MISMATCH, ERR_UNSUPPORTED_PROTOCOL_VERSION, ERR_METHOD_NOT_FOUND, ERR_INVALID_PARAMS, ERR_INTERNAL, LEGACY_RESOURCE_NOT_FOUND, LIST_TTL_MS, DISCOVER_TTL_MS, CACHE_SCOPE, CACHEABLE_METHODS, FORWARDED_METHODS, NAME_HEADER_METHODS, MRTR_METHODS, LONG_RUNNING_TOOLS, TASK_TTL_MS, TASK_POLL_INTERVAL_MS, MODERN_ONLY_METHODS, BASE64_SENTINEL_PREFIX, BASE64_SENTINEL_SUFFIX, bus, EVT_TOOLS_CHANGED, EVT_TASK, tasks, taskInputHooks;
+var init_protocol_2026 = __esm({
+  "src/protocol-2026.ts"() {
+    "use strict";
+    init_inMemory();
+    PROTOCOL_2026 = "2026-07-28";
+    BRIDGE_VERSION = "2025-11-25";
+    SUPPORTED_PROTOCOL_VERSIONS2 = [
+      PROTOCOL_2026,
+      "2025-11-25",
+      "2025-06-18",
+      "2025-03-26",
+      "2024-11-05"
+    ];
+    META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+    META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+    META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+    META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+    META_LOG_LEVEL = "io.modelcontextprotocol/logLevel";
+    META_SUBSCRIPTION_ID = "io.modelcontextprotocol/subscriptionId";
+    TASKS_EXTENSION = "io.modelcontextprotocol/tasks";
+    ERR_HEADER_MISMATCH = -32020;
+    ERR_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+    ERR_METHOD_NOT_FOUND = -32601;
+    ERR_INVALID_PARAMS = -32602;
+    ERR_INTERNAL = -32603;
+    LEGACY_RESOURCE_NOT_FOUND = -32002;
+    LIST_TTL_MS = 6e4;
+    DISCOVER_TTL_MS = 3e5;
+    CACHE_SCOPE = "private";
+    CACHEABLE_METHODS = /* @__PURE__ */ new Map([
+      ["server/discover", DISCOVER_TTL_MS],
+      ["tools/list", LIST_TTL_MS],
+      ["prompts/list", LIST_TTL_MS],
+      ["resources/list", LIST_TTL_MS],
+      ["resources/templates/list", LIST_TTL_MS],
+      ["resources/read", LIST_TTL_MS]
+    ]);
+    FORWARDED_METHODS = /* @__PURE__ */ new Set([
+      "tools/list",
+      "tools/call",
+      "resources/list",
+      "resources/templates/list",
+      "resources/read",
+      "prompts/list",
+      "prompts/get",
+      "completion/complete"
+    ]);
+    NAME_HEADER_METHODS = /* @__PURE__ */ new Set(["tools/call", "prompts/get"]);
+    MRTR_METHODS = /* @__PURE__ */ new Set(["tools/call", "prompts/get", "resources/read"]);
+    LONG_RUNNING_TOOLS = /* @__PURE__ */ new Set([
+      "route_nets",
+      "route_diff_pair",
+      "length_match_traces",
+      "fab_prep",
+      "fix_drc",
+      "topology_optimize",
+      "optimize_electrodes",
+      "export_video",
+      "render_sequence",
+      "simulate_flow",
+      "simulate_em",
+      "simulate_photonics",
+      "simulate_charged_particles",
+      "simulate_neutron_shield",
+      "simulate_lattice_gauge",
+      "md_run",
+      "minimize_energy",
+      "homogenize_material",
+      "design_material"
+    ]);
+    TASK_TTL_MS = 30 * 6e4;
+    TASK_POLL_INTERVAL_MS = 1e3;
+    MODERN_ONLY_METHODS = /* @__PURE__ */ new Set([
+      "server/discover",
+      "subscriptions/listen",
+      "tasks/get",
+      "tasks/update",
+      "tasks/cancel"
+    ]);
+    BASE64_SENTINEL_PREFIX = "=?base64?";
+    BASE64_SENTINEL_SUFFIX = "?=";
+    bus = new EventEmitter();
+    bus.setMaxListeners(100);
+    EVT_TOOLS_CHANGED = "tools_list_changed";
+    EVT_TASK = "task";
+    tasks = /* @__PURE__ */ new Map();
+    taskInputHooks = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 async function main() {
   const server = await createServer(void 0, { user: null });
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  const legacyOnMessage = transport.onmessage?.bind(transport);
+  const listens = /* @__PURE__ */ new Map();
+  transport.onmessage = (msg) => {
+    if (!isModernMessage(msg)) {
+      const m = msg;
+      const cancelId = m.params?.requestId;
+      if (m.method === "notifications/cancelled" && cancelId !== void 0 && listens.has(cancelId)) {
+        listens.get(cancelId).close();
+        listens.delete(cancelId);
+        return;
+      }
+      legacyOnMessage?.(msg);
+      return;
+    }
+    const method = msg.method;
+    if (method === "subscriptions/listen") {
+      const id = msg.id;
+      const handle = handleModernListen(msg, {
+        send: (m) => void transport.send(m)
+      });
+      if (id !== void 0) listens.set(id, handle);
+      return;
+    }
+    void handleModernRequest(msg, {
+      createServer: () => createServer(void 0, { user: null }),
+      // Request-scoped notifications share the stdio channel; the SDK
+      // client correlates progress via its progressToken.
+      onNotification: (n) => void transport.send(n)
+    }).then(({ body }) => {
+      if (body !== null) {
+        void transport.send(body);
+      }
+    });
+  };
 }
 var init_index = __esm({
   "src/index.ts"() {
     "use strict";
     init_stdio2();
     init_server3();
+    init_protocol_2026();
     console.log = (...args) => console.error(...args);
     main().catch((err7) => {
       console.error("Fatal error:", err7);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.9.4-main.47",
+  "version": "0.9.4-main.48",
   "description": "vcad MCP server — parametric CAD + PCB design tools for AI agents (self-contained: bundled server + kernel WASM)",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,7 @@
   },
   "homepage": "https://vcad.io",
   "vcadBuild": {
-    "sha": "e8c30217ef94fd492ae13caee599b581d8334d34",
-    "builtAt": "2026-07-26T17:13:18.437Z"
+    "sha": "fe62ea0789005cd4b3f00777274323698634167d",
+    "builtAt": "2026-07-29T16:12:24.504Z"
   }
 }