* 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:
1 parent
f815491936
commit
2b1cb2c4e1
5 files changed
+104
-20
No files matched your search
@@ -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.
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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
@@ -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() {
|
||||
|
||||
@@ -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) |
|
||||
|
||||
|
||||
Reference in new issue
Block a user