From 2b1cb2c4e1eab82858ae87202fea8f6066905b89 Mon Sep 17 00:00:00 2001 From: Dahak Builds Date: Wed, 21 Oct 2026 00:15:36 +0000 Subject: [PATCH] MCP batch: rollback restores the original document (#3242) (#3288) * claim: #3242 * MCP batch: rollback restores the design the batch began in (#3242) A failed batch with rollback: true reported rolled_back: true even when the design never went back. Two defects, both fixed: - file.new (and any document-replacing command) replaced the session with it, taking its checkpoints down too, so a batch that failed after file.new had nothing to restore. Session::replace_design now carries the checkpoints over to the fresh session: the checkpoint belongs to the batch, not to the session that happened to be holding the document. - rolled_back echoed the requested flag. It now reports whether the design is actually back: the app answers engine.batch with a new restored field, and the MCP tool reports restored && rollback. An app that predates the field falls back to undone/completed. * Batch: answer with main's rolled_back field after the merge (#3242) Upstream #2900 put the real restore check on engine.batch as `rolled_back` while this branch named it `restored`; the merge kept main's control test and this branch's field, and CI caught it. Standardize on main's wire name: the app answers `rolled_back`, the MCP tool reads it (fallback for older apps unchanged), docs and tests follow. The checkpoint carry-over across file.new is unchanged. --------- Co-authored-by: DahakBuilds --- crates/engine/src/lib.rs | 8 ++++++ crates/engine/src/tests.rs | 17 +++++++++++++ crates/mcp/src/tests.rs | 50 ++++++++++++++++++++++++++++++++++++++ crates/mcp/src/tools.rs | 47 ++++++++++++++++++++--------------- docs/control-protocol.md | 2 +- 5 files changed, 104 insertions(+), 20 deletions(-) diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 3eae93671..6c587973b 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -431,16 +431,24 @@ impl Session { /// Become `fresh` (another design opened, recovered or started), keeping the settings that /// are the user's rather than the design's: `auto_project` is a preference (#680). + /// Checkpoints survive too: a batch that failed after `file.new` or `doc.open` goes back + /// from the checkpoint it took before its first step, and that checkpoint belongs to the + /// design before the batch, which is what the batch promised (#3242). The design is what a + /// checkpoint keeps, not the replaced session's file path (docs/mcp.md). pub fn replace_design(&mut self, fresh: Session) { let auto_project = self.auto_project; let param_check = self.param_check; let render_viewport = self.render_viewport.clone(); let render_jobs = self.render_jobs.scratch(); + let checkpoints = std::mem::take(&mut self.checkpoints); + let next_checkpoint = self.next_checkpoint; *self = fresh; self.auto_project = auto_project; self.param_check = param_check; self.render_viewport = render_viewport; self.render_jobs = render_jobs; + self.checkpoints = checkpoints; + self.next_checkpoint = next_checkpoint; } /// The design has changes not in its file: in the document, or in what is hidden. diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 42d9f57fe..5a3380b6e 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -1785,6 +1785,23 @@ fn checkpoint_restores_with_a_full_undo_history() { assert!(s.execute("edit.restore_checkpoint", &json!({"checkpoint": id})).is_err()); } +/// Regression (#3242): `file.new` replaced the session and its checkpoints with it, so a +/// batch that failed after `file.new` could not go back to the design it began in. +#[test] +fn a_checkpoint_survives_file_new() { + let mut s = Session::default(); + run(&mut s, "solid.box", json!({"length": 1.0, "width": 1.0, "height": 1.0})); + let id = run(&mut s, "edit.checkpoint", json!({}))["checkpoint"].as_u64().unwrap(); + run(&mut s, "file.new", json!({"name": "Replacement"})); + run(&mut s, "solid.box", json!({"length": 2.0, "width": 2.0, "height": 2.0})); + assert_eq!(run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64(), Some(8.0)); + run(&mut s, "edit.restore_checkpoint", json!({"checkpoint": id})); + assert_eq!(run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64(), Some(1.0)); + // The undo history is the restored design's own: one step back is the empty design. + run(&mut s, "edit.undo", json!({})); + assert_eq!(run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64(), Some(0.0)); +} + #[test] fn components_occurrences_and_world_placement() { let mut s = Session::default(); diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs index 8ac811edd..71cdb9513 100644 --- a/crates/mcp/src/tests.rs +++ b/crates/mcp/src/tests.rs @@ -421,6 +421,35 @@ fn batch_rolls_back_with_a_full_undo_history() { assert_eq!(d["undo"], undo); } +/// Regression (#3242): a failed batch containing `file.new` reported `rolled_back: true` and +/// kept the replacement design. The checkpoint survives the new document, so the design the +/// batch started in — the 1 mm cube — is back when the batch fails. +#[test] +fn a_failed_batch_with_file_new_restores_the_original_design() { + let mut s = server(); + tool(&mut s, "batch", json!({"commands": [{"command": "solid.box", "params": {"length": 1, "width": 1, "height": 1, "body_name": "Original"}}]})); + let name = tool(&mut s, "inspect_design", json!({"measure": false, "sketches": false}))["name"].clone(); + let r = raw_tool( + &mut s, + "batch", + json!({"rollback": true, "commands": [ + {"command": "file.new", "params": {"name": "Replacement"}}, + {"command": "solid.box", "params": {"length": 2, "width": 2, "height": 2}}, + {"command": "not.a.command"}, + ]}), + ); + assert_eq!(r["result"]["isError"], true, "{r}"); + let body: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap(); + assert_eq!(body["failed"]["index"], 2, "{body}"); + assert_eq!(body["rolled_back"], true, "{body}"); + assert_eq!(body["undone"], 2, "{body}"); + // The original 1 mm cube is back; the replacement design is gone. + assert_eq!(tool(&mut s, "measure", json!({}))["body_count"], 1); + assert!(rel(volume(&mut s), 1.0) < 1e-9, "{}", volume(&mut s)); + let d = tool(&mut s, "inspect_design", json!({"measure": false, "sketches": false})); + assert_eq!(d["name"], name, "{d}"); +} + #[test] fn helper_sketches_can_be_hidden() { let mut s = server(); @@ -1346,6 +1375,27 @@ fn batch_reports_a_failed_engine_batch_like_before() { ); } +/// `rolled_back` tells whether the design went back, not whether a rollback was asked for +/// (#3242): the app's `rolled_back`, or, for an app that predates that field, none of the +/// completed steps undone means the design did not go back. +#[test] +fn a_batch_the_app_could_not_roll_back_reports_it() { + let failed = |reply: Value| { + let (_, body, is_error) = recorded_batch(Ok(reply), json!({"commands": [{"command": "a.one"}, {"command": "a.two"}]})); + assert!(is_error); + body + }; + let body = failed( + json!({"completed": 1, "results": [{"x": 1}], "failed": {"index": 1, "command": "a.two", "error": "boom"}, "rolled_back": false, "undone": 0}), + ); + assert_eq!(body["rolled_back"], false, "{body}"); + let body = failed(json!({"completed": 1, "results": [{"x": 1}], "failed": {"index": 1, "command": "a.two", "error": "boom"}, "undone": 0})); + assert_eq!(body["rolled_back"], false, "{body}"); + // A first step that failed left nothing to take back. + let body = failed(json!({"completed": 0, "results": [], "failed": {"index": 0, "command": "a.one", "error": "boom"}, "undone": 0})); + assert_eq!(body["rolled_back"], true, "{body}"); +} + #[test] fn batch_falls_back_when_the_app_lacks_engine_batch() { let (b, body, is_error) = diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs index ef720a0e1..2139a6a6b 100644 --- a/crates/mcp/src/tools.rs +++ b/crates/mcp/src/tools.rs @@ -500,12 +500,13 @@ impl Undo { } } - /// Go back; the number of steps undone. - fn rollback(self, b: &mut dyn Backend, steps: usize) -> u64 { + /// Go back; (whether the design is back as it was, the number of steps undone). A failed + /// rollback says so rather than reporting the flag the caller asked for (#3242). + fn rollback(self, b: &mut dyn Backend, steps: usize) -> (bool, u64) { match self { Undo::Checkpoint(id) => match exec(b, "edit.restore_checkpoint", json!({"checkpoint": id})) { - Ok(_) => steps as u64, - Err(_) => 0, + Ok(_) => (true, steps as u64), + Err(_) => (false, 0), }, Undo::Depth(before) => { let after = undo_depth(b).unwrap_or(before); @@ -516,9 +517,10 @@ impl Undo { } undone += 1; } - undone + (undone == steps as u64, undone) } - Undo::None => 0, + // Nothing remembered the design; only a first step that failed left nothing behind. + Undo::None => (steps == 0, 0), } } @@ -583,12 +585,12 @@ fn batch(b: &mut dyn Backend, a: &Map) -> Value { match r { Ok(v) => results.push(if verbose { v } else { compact(v) }), Err(e) => { - let undone = start.rollback(b, i); + let (rolled_back, undone) = start.rollback(b, i); let reply = json!({ "ok": false, "completed": i, "failed": {"index": i, "command": command, "error": e}, - "rolled_back": rollback, + "rolled_back": rolled_back, "undone": undone, "results": results, }); @@ -616,17 +618,24 @@ fn batch_reply(r: &Value, rollback: bool, verbose: bool) -> Value { r["results"].as_array().cloned().unwrap_or_default().into_iter().map(|v| if verbose { v } else { compact(v) }).collect(); let (mut reply, error) = match r.get("failed").filter(|f| !f.is_null()) { None => (json!({"ok": true, "completed": results.len(), "results": results}), false), - Some(failed) => ( - json!({ - "ok": false, - "completed": r["completed"], - "failed": failed, - "rolled_back": rollback, - "undone": r["undone"], - "results": results, - }), - true, - ), + Some(failed) => { + // `rolled_back` tells whether the design went back, not whether a rollback was + // asked for (#3242): the app answers with its own `rolled_back`; an app that + // predates that field and undid none of the steps it had completed did not go back. + let undone = r["undone"].as_u64().unwrap_or(0); + let went_back = r.get("rolled_back").and_then(Value::as_bool).unwrap_or(undone > 0 || r["completed"].as_u64() == Some(0)); + ( + json!({ + "ok": false, + "completed": r["completed"], + "failed": failed, + "rolled_back": rollback && went_back, + "undone": r["undone"], + "results": results, + }), + true, + ) + } }; // The app timed the steps where they ran. if let Some(o) = reply.as_object_mut() { diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 92a1d9bc6..9cf50862c 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -74,7 +74,7 @@ MCP server sends its folders this way on every request ([mcp.md](mcp.md)). Witho |---|---|---| | `engine.execute` | `command`: command id, `params`: JSON object | the command's result | | `engine.script` | `commands`: `[{command, params}, …]` | results, stops at the first error | -| `engine.batch` | `commands`: `[{command, params}, …]` (at most 10 000), `rollback?`: bool (default true), `timings?`, `profile?`: bool (default false) | `{completed, results, undone}`, plus `failed: {index, command, error}` when a step fails, and with `timings` `timings: [{index, command, ms}]` (the failing step included) and `total_ms`; `profile` adds each step's `profile: {boolean_ms, tessellate_ms, other_ms}`. Runs the steps in one request, so within one frame, each as `engine.execute` runs it. The first failure stops the batch, and with `rollback` the design goes back to how it was before it (`undone`: the steps taken back). Refused before anything runs, with an error starting `engine.batch unavailable`, while the agent cursor is shown or when a step loads a file (`doc.open`, `file.insert_step`, `file.insert_mesh`). Send such steps one by one. Answered when done, for up to 3600 s | +| `engine.batch` | `commands`: `[{command, params}, …]` (at most 10 000), `rollback?`: bool (default true), `timings?`, `profile?`: bool (default false) | `{completed, results, undone}`, plus `failed: {index, command, error}` when a step fails, and with `timings` `timings: [{index, command, ms}]` (the failing step included) and `total_ms`; `profile` adds each step's `profile: {boolean_ms, tessellate_ms, other_ms}`. Runs the steps in one request, so within one frame, each as `engine.execute` runs it. The first failure stops the batch, and with `rollback` the design goes back to how it was before it (`undone`: the steps taken back, `rolled_back`: whether the design is back as it was, `false` only when the checkpoint could not restore it). Refused before anything runs, with an error starting `engine.batch unavailable`, while the agent cursor is shown or when a step loads a file (`doc.open`, `file.insert_step`, `file.insert_mesh`). Send such steps one by one. Answered when done, for up to 3600 s | | `engine.commands` | — | every command: id, label, tab, panel, icon, shortcut, params doc, enabled | | `document.inspect` | `measure?`: bool | parameters, timeline (errors, timings), bodies, sketches, selection (assembly joints: `engine.execute` `joint.inspect {joint?}`, which reads only: each joint's two origins with the occurrence, the snap as saved, the feature, face, edge or sketch curve its names refer to, and whether it resolves or why not; kind, offset, angle, flip, values, limits, expressions and motion links) |