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 <dahakbuilds@users.noreply.github.com>
This commit is contained in:
Dahak BuildsandDahakBuilds authored and GitHub committed 2026-10-21 00:15:36 +00:00
1 parent f815491936
commit 2b1cb2c4e1
5 files changed
+104 -20

No files matched your search

+8
View File
@@ -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.
+17
View File
@@ -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();
+50
View File
@@ -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) =
+28 -19
View File
@@ -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<String, Value>) -> 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() {
+1 -1
View File
@@ -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) |