@vcad/mcp 0.9.4-main.49 → 0.9.4-main.50

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 40ccc073edea8494ce6e1a94ea360bf79cfc630d at 2026-07-29T16:38:39.110Z. Source: https://github.com/ecto/vcad
+Built from 6da108761001bf4957ffbaef8e90cc4a9f4a8b50 at 2026-07-29T18:21:09.646Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -53582,6 +53582,12 @@ async function handleModernRequest(msg, opts) {
       onNotification: (n) => {
         const nm = n.method;
         if (nm === "notifications/message" && !wantsLogs) return;
+        if (nm === "notifications/progress" && bridgeRef) {
+          const tctx = taskInputHooks.get(bridgeRef);
+          if (tctx && tctx.record.status === "working") {
+            touchTask(tctx.record, void 0, progressStatusMessage(tctx.record.toolName, n));
+          }
+        }
         opts.onNotification?.(n);
       },
       onServerRequest
@@ -53608,6 +53614,7 @@ async function handleModernRequest(msg, opts) {
       version: "0.0.0"
     };
     const forwarded = stripModernFields(params);
+    if (method === "tools/call") ensureProgressToken(forwarded);
     if (asTask) {
       pruneTasks();
       const record2 = createTaskRecord(params.name);
@@ -53682,6 +53689,19 @@ function stripModernFields(params) {
   }
   return out;
 }
+function ensureProgressToken(forwarded) {
+  const meta = forwarded._meta && typeof forwarded._meta === "object" ? { ...forwarded._meta } : {};
+  if (meta.progressToken === void 0) meta.progressToken = BRIDGE_PROGRESS_TOKEN;
+  forwarded._meta = meta;
+}
+function progressStatusMessage(toolName, n) {
+  const p = n.params ?? {};
+  const message = typeof p.message === "string" ? p.message : void 0;
+  const progress = typeof p.progress === "number" ? p.progress : void 0;
+  const total = typeof p.total === "number" ? p.total : void 0;
+  const counter = progress !== void 0 ? total !== void 0 ? ` (${progress}/${total})` : ` (${progress})` : "";
+  return `${message ?? `running ${toolName}`}${counter}`;
+}
 function createTaskRecord(toolName) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const record2 = {
@@ -53840,7 +53860,7 @@ function handleModernListen(msg, sink) {
     }
   };
 }
-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 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, BRIDGE_PROGRESS_TOKEN, taskInputHooks;
 var init_protocol_2026 = __esm({
   "src/protocol-2026.ts"() {
     "use strict";
@@ -53927,6 +53947,7 @@ var init_protocol_2026 = __esm({
     EVT_TOOLS_CHANGED = "tools_list_changed";
     EVT_TASK = "task";
     tasks = /* @__PURE__ */ new Map();
+    BRIDGE_PROGRESS_TOKEN = "modern-bridge-progress";
     taskInputHooks = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -61108,7 +61129,8 @@ async function netIslandCounts(pcb, nets) {
   }
   return counts;
 }
-async function routeNets(args) {
+async function routeNets(args, toolCtx) {
+  const progress = toolCtx?.progress;
   const ctx = resolveDocInput(args);
   const doc = ctx.doc;
   const traceWidth = args.trace_width || void 0;
@@ -61126,6 +61148,7 @@ async function routeNets(args) {
   }
   const width = traceWidth || pcb.rules.defaultRules.traceWidth;
   const wantReceipt = Boolean(args.receipt);
+  if (wantReceipt) progress?.(0, void 0, "snapshotting pre-route DRC");
   const beforeSnap = wantReceipt ? await drcPcb(pcb, "full", 500) : null;
   const netConnections = /* @__PURE__ */ new Map();
   for (const fp of pcb.footprints) {
@@ -61261,15 +61284,18 @@ async function routeNets(args) {
   };
   let routedSomething = false;
   if (strategy === "auto") {
+    progress?.(0, void 0, "routing all nets (negotiated whole-board pass)");
     const result = await routeAll(pcb, width, routeFilter, effort);
     routedSomething = result.traces.length > 0 || result.vias.length > 0 || result.unrouted_nets.length > 0;
     if (routedSomething) applyRoute(result);
   } else {
     const universe = routeFilter.length > 0 ? routeFilter : [...netConnections.keys()].filter((n) => !preservedNets.has(n));
     const tiers = [...new Set(universe.map(tierOf))].sort((a, b) => a - b);
-    for (const tier of tiers) {
+    for (let ti = 0; ti < tiers.length; ti++) {
+      const tier = tiers[ti];
       const nets = universe.filter((n) => tierOf(n) === tier);
       if (nets.length === 0) continue;
+      progress?.(ti, tiers.length, `routing tier ${ti + 1}/${tiers.length} (${nets.length} net(s))`);
       const result = await routeAll(pcb, width, nets, effort);
       if (result.traces.length > 0 || result.vias.length > 0 || result.unrouted_nets.length > 0) {
         routedSomething = true;
@@ -61304,6 +61330,7 @@ async function routeNets(args) {
   }
   const connectivityRegressions = {};
   if (islandsBefore && copperBefore) {
+    progress?.(0, void 0, "verifying net connectivity");
     const before = islandsBefore;
     const worseNets = async (nets) => {
       const counts = await netIslandCounts(pcb, nets);
@@ -61323,6 +61350,7 @@ async function routeNets(args) {
       if (retrySet.size > 0) {
         pcb.traces = pcb.traces.filter((t2) => !retrySet.has(t2.net) || t2.source === "manual");
         pcb.vias = pcb.vias.filter((v) => !retrySet.has(v.net) || v.source === "manual");
+        progress?.(0, void 0, `re-routing ${retrySet.size} net(s) with regressed connectivity`);
         const retried = await routeAll(pcb, width, [...retrySet], effort);
         applyRoute(retried);
       }
@@ -61615,7 +61643,8 @@ async function routeDiffPair2(args) {
     ]
   };
 }
-async function lengthMatchTraces(args) {
+async function lengthMatchTraces(args, toolCtx) {
+  const progress = toolCtx?.progress;
   const ctx = resolveDocInput(args);
   const pcb = getDocPcb2(ctx.doc);
   const fail2 = ecadError;
@@ -61631,6 +61660,7 @@ async function lengthMatchTraces(args) {
   if (style !== void 0 && style !== "trombone" && style !== "sawtooth") {
     return fail2("style must be 'trombone' or 'sawtooth'");
   }
+  progress?.(0, void 0, `length-matching ${nets.length} net(s)`);
   const result = await matchTraceLengths(pcb, nets, {
     target_length: args.target_length,
     tolerance: args.tolerance,
@@ -61671,6 +61701,9 @@ async function lengthMatchTraces(args) {
     };
   }
   const tuned = result.nets.filter((n) => n.tuned && n.new_traces && n.new_traces.length > 0);
+  if (tuned.length > 0) {
+    progress?.(0, void 0, `verifying DRC delta for ${tuned.length} tuned net(s)`);
+  }
   const touched = new Set(tuned.map((n) => n.net));
   const newPoints = tuned.flatMap(
     (n) => (n.new_traces ?? []).flatMap((t2) => [t2.start, t2.end])
@@ -67659,7 +67692,8 @@ function onBoard(p, outline) {
 function samePoint(a, b, eps = FIX_EPS) {
   return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps;
 }
-async function fixDrc(args) {
+async function fixDrc(args, toolCtx) {
+  const progress = toolCtx?.progress;
   const ctx = resolveDocInput(args);
   const pcb = getDocPcb2(ctx.doc);
   if (!pcb) {
@@ -67675,6 +67709,7 @@ async function fixDrc(args) {
   const dryRun = Boolean(args.dry_run);
   const effort = Math.min(100, Math.max(0.1, Number(args.reroute_effort) || 4));
   const maxFixes = Math.max(1, Math.round(Number(args.max_fixes) || 50));
+  progress?.(0, void 0, "running initial DRC");
   const before = await drcPcb(pcb, "full", 20);
   if (!before.success) return ecadUnverifiable("fix_drc", before);
   const viols = before.details ?? [];
@@ -67687,7 +67722,9 @@ async function fixDrc(args) {
     if (existing) existing.count++;
     else skipped.push({ rule, reason, count: 1, ...message ? { sample_message: message } : {} });
   };
+  let fixAttempts = 0;
   const applyVerified = async (bounds, mutate) => {
+    progress?.(++fixAttempts, void 0, `verifying fix ${fixAttempts} (${fixed.length} applied so far)`);
     const savedTraces = pcb.traces;
     const savedVias = pcb.vias;
     const cap = await beginDrcDelta(pcb, bounds);
@@ -67979,6 +68016,7 @@ async function fixDrc(args) {
       budget--;
       continue;
     }
+    progress?.(++fixAttempts, void 0, `re-routing net '${net}' (${fixed.length} fix(es) applied so far)`);
     const savedTraces = pcb.traces;
     const savedVias = pcb.vias;
     const cap = await beginDrcDelta(pcb, "full");
@@ -68010,6 +68048,7 @@ async function fixDrc(args) {
     const reason = FIX_DRC_NEVER[v.rule];
     if (reason) skip(v.rule, reason, v.message);
   }
+  if (!dryRun) progress?.(0, void 0, "running final DRC");
   const after = dryRun ? before : await drcPcb(pcb, "full", 20);
   const brief = (s) => ({
     violations: s.violations,
@@ -69678,7 +69717,7 @@ var init_ecad2 = __esm({
         pack: "ecad",
         description: "Route electrical nets on the PCB with copper traces. Connects pads belonging to the same net. Idempotent: re-running rips up the previously autorouted copper on the target nets before routing, so a second call replaces the route instead of stacking shorts. Hand-placed copper (add_trace / add_via / coils) is preserved automatically; `locked_nets` additionally protects whole nets. A net with a copper-pour zone (a plane) is connected by stitching each pad to the plane with a via instead of tracing it \u2014 those nets come back in `plane_stitched`. Mutates the session document (pass document_id).",
         inputSchema: routeNetsSchema,
-        handler: (a) => routeNets(a),
+        handler: (a, c) => routeNets(a, c),
         behavior: behavior({ writesDoc: true, geometry: true })
       },
       {
@@ -69960,7 +69999,7 @@ var init_ecad2 = __esm({
         pack: "ecad",
         description: "Run DRC and automatically apply the mechanically-safe subset of fixes: stitching vias for UnstitchedPad, dedupe of overlapping same-net via drills (HoleToHole), inward nudges for EdgeClearance when a legal corridor exists, and per-net rip-up + re-route (at higher effort) for UnconnectedNet/NetIslands. Every fix is individually verified with a DRC delta and REVERTED if it would introduce any new violation. Never touches design decisions: different-net shorts/clearance, courtyard overlaps, keepouts, or anything requiring a component move. Returns a fail-closed receipt: before/after violation counts, what was fixed, and what was skipped with the reason. `dry_run` plans without mutating. Mutates the session document (pass document_id).",
         inputSchema: fixDrcSchema,
-        handler: (a) => fixDrc(a),
+        handler: (a, c) => fixDrc(a, c),
         behavior: behavior({ writesDoc: true, geometry: true })
       },
       {
@@ -70024,7 +70063,7 @@ var init_ecad2 = __esm({
         pack: null,
         description: "Length-match a group of routed nets (a DDR lane, clock tree, SPI bus): measures each net's copper and grows the shorter ones with clearance-checked trombone/sawtooth meanders until all reach the longest net (or target_length) within tolerance. Nets it can't tune (branching, multi-layer, arcs, no room) are reported with a reason, never guessed at. check_only:true measures and verdicts without touching copper. Mutating runs carry drc_delta.",
         inputSchema: lengthMatchTracesSchema,
-        handler: (a) => lengthMatchTraces(a),
+        handler: (a, c) => lengthMatchTraces(a, c),
         behavior: behavior({ writesDoc: true, geometry: true })
       },
       {
@@ -77467,12 +77506,22 @@ async function minimizeEnergyTool(input) {
     return fail(err7);
   }
 }
-async function mdRun(input) {
+async function mdRun(input, toolCtx) {
   try {
     const args = input;
     const env = await MdEnv.create(args.molecule, args.config ?? {});
     try {
-      const observation = env.run(args.steps);
+      const total = Math.max(1, Math.round(args.steps));
+      const chunk = toolCtx?.progress ? Math.max(1, Math.ceil(total / 10)) : total;
+      let done = 0;
+      let observation = env.run(Math.min(chunk, total));
+      done += Math.min(chunk, total);
+      while (done < total) {
+        toolCtx?.progress?.(done, total, `MD step ${done}/${total}`);
+        const n = Math.min(chunk, total - done);
+        observation = env.run(n);
+        done += n;
+      }
       const molecule = env.molecule();
       return okPretty({ observation, molecule });
     } finally {
@@ -77508,7 +77557,7 @@ function scaleMolecule(mol, s) {
   } : mol.cell;
   return { ...mol, positions, cell };
 }
-async function designMaterial(input) {
+async function designMaterial(input, toolCtx) {
   try {
     const args = input;
     const [lo0, hi0] = args.scale_bounds ?? [0.5, 2];
@@ -77536,6 +77585,7 @@ async function designMaterial(input) {
     let s = 1;
     let prop = await measure2(base);
     for (let it = 0; it < 60; it++) {
+      toolCtx?.progress?.(it, 60, `bisection iteration ${it + 1}: property ${prop.toFixed(4)} \u2192 target ${args.target}`);
       s = 0.5 * (lo + hi);
       prop = await measure2(scaleMolecule(base, s));
       const tooSmall = increasing ? prop < args.target : prop > args.target;
@@ -77866,7 +77916,7 @@ var init_atoms2 = __esm({
         pack: "atoms",
         description: "Run molecular dynamics (velocity-Verlet, optional Berendsen thermostat) for N steps and return the final observation (energies, temperature, max force) and the evolved structure.",
         inputSchema: mdRunSchema,
-        handler: (a) => mdRun(a),
+        handler: (a, c) => mdRun(a, c),
         behavior: behavior({})
       },
       {
@@ -77874,7 +77924,7 @@ var init_atoms2 = __esm({
         pack: "atoms",
         description: "Inverse design: search an isotropic scale factor that drives a geometric property (nearest-neighbor distance or radius of gyration) to a target value, returning the reshaped molecule and a receipt. The energy-objective inverse design (gradients through the simulation) lives in the Rust kernel.",
         inputSchema: designMaterialSchema,
-        handler: (a) => designMaterial(a),
+        handler: (a, c) => designMaterial(a, c),
         behavior: behavior({})
       },
       {
@@ -79835,7 +79885,7 @@ function explodeDirections(doc, transforms) {
   });
   return dirs;
 }
-function buildSequenceGlb(doc, timeline, frames, engine) {
+function buildSequenceGlb(doc, timeline, frames, engine, onProgress) {
   const channels = [];
   const meshes = [];
   const paramFrames = frames.filter((f) => f.geometryDirty);
@@ -79938,6 +79988,7 @@ function buildSequenceGlb(doc, timeline, frames, engine) {
     geoSamples = sampled.length;
     const labels = buildPartLabels(doc);
     for (let k = 0; k < sampled.length; k++) {
+      onProgress?.(k, sampled.length, `evaluating geometry sample ${k + 1}/${sampled.length}`);
       const frame = sampled[k];
       const posed = poseDocument(doc, frame);
       let scene;
@@ -80028,9 +80079,10 @@ ${issues.map((i) => i.problem).join("\n")}`
       `sequence has ${frames.length} frames (max ${MAX_FRAMES}); lower fps or duration.`
     );
   }
-  const built = buildSequenceGlb(doc, timeline, frames, ctx.engine);
+  const built = buildSequenceGlb(doc, timeline, frames, ctx.engine, ctx.progress);
   if (!built) return err2("document has no previewable geometry to animate.");
   const wantVerify = args.verify !== false;
+  if (wantVerify) ctx.progress?.(frames.length, frames.length, "verifying clearance specs");
   const verification = wantVerify ? verifySequenceClearance(doc, frames, ctx.engine) : null;
   const b64 = Buffer.from(built.glb).toString("base64");
   const body = {
@@ -80268,6 +80320,7 @@ ${issues.map((i) => i.problem).join("\n")}`);
     return err2(message);
   };
   for (let i = 0; i < frames.length; i++) {
+    ctx.progress?.(i, frames.length, `rendering frame ${i + 1}/${frames.length}`);
     const frame = frames[i];
     const posed = poseDocument(doc, frame);
     let svg;
@@ -80322,6 +80375,7 @@ ${issues.map((i) => i.problem).join("\n")}`);
     }
   }
   if (!size) return err2("no frames rendered.");
+  ctx.progress?.(frames.length, frames.length, "encoding video");
   let bytes;
   let mime;
   let filename;
@@ -81162,8 +81216,24 @@ async function createServer(existingEngine, context = { user: null }) {
     } catch {
     }
   };
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
     const { name, arguments: args = {} } = request.params;
+    const progressToken = request.params._meta?.progressToken;
+    const callCtx = progressToken === void 0 ? ctx : {
+      ...ctx,
+      progress: (current, total, message) => {
+        void extra.sendNotification({
+          method: "notifications/progress",
+          params: {
+            progressToken,
+            progress: current,
+            ...total !== void 0 ? { total } : {},
+            ...message !== void 0 ? { message } : {}
+          }
+        }).catch(() => {
+        });
+      }
+    };
     if (disabledTools.has(name)) {
       const pack = dispatchMap.get(name)?.pack;
       const enableHint = pack ? `Enable it with set_tool_packs({ enable: ["${pack}"] }) or set VCAD_MCP_PACKS.` : "Enable its pack to use it.";
@@ -81221,7 +81291,7 @@ async function createServer(existingEngine, context = { user: null }) {
           fireToolAlert(name, args, refusal);
           return refusal;
         }
-        const result = await def.handler(args, ctx);
+        const result = await def.handler(args, callCtx);
         if (def.behavior.geometry && result.content.length > 0 && !result.isError) {
           const docId = resolvePreviewDocumentId(name, result, args, engine);
           if (docId) {
@@ -81544,8 +81614,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.49") {
-        return "0.9.4-main.49";
+      if ("0.9.4-main.50") {
+        return "0.9.4-main.50";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -81554,8 +81624,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "40ccc073edea8494ce6e1a94ea360bf79cfc630d";
-    BUILD_TIME = "2026-07-29T16:38:39.110Z";
+    BUILD_SHA = "6da108761001bf4957ffbaef8e90cc4a9f4a8b50";
+    BUILD_TIME = "2026-07-29T18:21:09.646Z";
     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 = randomUUID7().slice(0, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.9.4-main.49",
+  "version": "0.9.4-main.50",
   "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": "40ccc073edea8494ce6e1a94ea360bf79cfc630d",
-    "builtAt": "2026-07-29T16:38:39.110Z"
+    "sha": "6da108761001bf4957ffbaef8e90cc4a9f4a8b50",
+    "builtAt": "2026-07-29T18:21:09.646Z"
   }
 }