* claim: #5822 * Batch: consecutive parameter edits can rebuild the design once (#5822) An agent's batch of parameter edits, one parameter per step, evaluated the design once per edit: an edit early in the timeline rebuilds nearly all of it, and 21 such edits ran for minutes. engine.batch and the MCP batch tool take coalesce_parameters (default false). With it, each run of consecutive plain parameter edits (parameters.change with only a name and an expression, or with changes) is set as one parameters.change {changes}: one rebuild for the run. Any other step ends a run, so later steps see the design up to date. Every step still gets its own result (coalesced: the run's length); the run is one undo step. A run whose combined edit is refused (a new parameter, which changes can't make; a bad expression) runs step by step, so a refused edit is still named by its own step. The app's off-thread evaluation computes the run the same way. The grouping is solidcraft_engine::batch_params, shared by both runners. 21 parameter edits on a plate with 21 extruded bosses (in-process MCP, ci profile): 40.1 s step by step, 3.5 s coalesced, the same volume. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Batch coalescing: say a run skips the states between its edits; test it against step by step (#5822) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
192 lines
8.5 KiB
Rust
192 lines
8.5 KiB
Rust
//! Parameter edits in a batch, rebuilt once (#5822).
|
|
//!
|
|
//! An agent often sends a batch of `parameters.change` steps, one parameter each. Every step
|
|
//! evaluates the design again, and an edit early in the timeline rebuilds nearly all of it: a
|
|
//! batch of 21 such edits ran for minutes. `parameters.change {changes}` sets several parameters
|
|
//! with one rebuild. With `coalesce_parameters`, a batch runner sends each run of consecutive
|
|
//! plain edits (a name and an expression, or `changes`) as one such step. When that combined
|
|
//! step is refused (a step makes a new parameter, which `changes` can't; an expression is
|
|
//! wrong), the runner runs the run's steps one by one as before, so a refused edit is still
|
|
//! named by its own step. Any other step (a sketch, an extrude, a rename) ends a run, so it sees
|
|
//! the design up to date. A run skips the states between its edits: an edit refused on its own
|
|
//! can go through together with the run's later edits.
|
|
|
|
use serde_json::{Map, Value, json};
|
|
|
|
/// How a batch's steps run.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum BatchRun {
|
|
/// One step as it is (its index).
|
|
Step(usize),
|
|
/// Consecutive plain parameter edits (their indices, at least two) as one
|
|
/// `parameters.change {changes}`: the parameters and expressions they set, the later of two
|
|
/// for one parameter.
|
|
Params { steps: Vec<usize>, changes: Map<String, Value> },
|
|
}
|
|
|
|
/// A step's command id (`command`, or `id` as the control channel also takes).
|
|
fn command(step: &Value) -> Option<&str> {
|
|
step.get("command").or_else(|| step.get("id")).and_then(Value::as_str)
|
|
}
|
|
|
|
/// The parameters a plain `parameters.change` step sets, with their expressions: `{name,
|
|
/// expression}` (or `value`), or `{changes}`. `None` for any other step or form (a rename, a
|
|
/// unit, a comment, a deletion), which then runs as it is.
|
|
fn plain_edit(step: &Value) -> Option<Map<String, Value>> {
|
|
if command(step)? != "parameters.change" {
|
|
return None;
|
|
}
|
|
let p = step.get("params")?.as_object()?;
|
|
let expression = |v: &Value| matches!(v, Value::Number(_) | Value::String(_));
|
|
if let Some(changes) = p.get("changes") {
|
|
let changes = changes.as_object().filter(|c| !c.is_empty() && c.values().all(expression))?;
|
|
return (p.len() == 1).then(|| changes.clone());
|
|
}
|
|
let name = p.get("name")?.as_str()?.trim();
|
|
let e = p.get("expression").or_else(|| p.get("value")).filter(|e| expression(e))?;
|
|
let plain = p.keys().all(|k| matches!(k.as_str(), "name" | "expression" | "value")) && !name.is_empty();
|
|
plain.then(|| Map::from_iter([(name.to_string(), e.clone())]))
|
|
}
|
|
|
|
/// How `steps` run: each on its own, or with `coalesce` each run of two or more consecutive
|
|
/// plain parameter edits as one.
|
|
pub fn plan(steps: &[Value], coalesce: bool) -> Vec<BatchRun> {
|
|
let mut out = Vec::new();
|
|
let mut run: Vec<(usize, Map<String, Value>)> = Vec::new();
|
|
let flush = |run: &mut Vec<(usize, Map<String, Value>)>, out: &mut Vec<BatchRun>| match run.len() {
|
|
0 => {}
|
|
1 => out.extend(run.drain(..).map(|(i, _)| BatchRun::Step(i))),
|
|
_ => {
|
|
let mut changes = Map::new();
|
|
let mut indices = Vec::with_capacity(run.len());
|
|
for (i, edit) in run.drain(..) {
|
|
indices.push(i);
|
|
// A later edit of a parameter replaces an earlier one, as it would have.
|
|
for (name, e) in edit {
|
|
changes.remove(&name);
|
|
changes.insert(name, e);
|
|
}
|
|
}
|
|
out.push(BatchRun::Params { steps: indices, changes });
|
|
}
|
|
};
|
|
for (i, step) in steps.iter().enumerate() {
|
|
match plain_edit(step).filter(|_| coalesce) {
|
|
Some(edit) => run.push((i, edit)),
|
|
None => {
|
|
flush(&mut run, &mut out);
|
|
out.push(BatchRun::Step(i));
|
|
}
|
|
}
|
|
}
|
|
flush(&mut run, &mut out);
|
|
out
|
|
}
|
|
|
|
/// The combined step: `parameters.change {changes}`.
|
|
pub fn combined_params(changes: &Map<String, Value>) -> Value {
|
|
json!({"changes": changes})
|
|
}
|
|
|
|
/// Each step's result from the combined step's `result`: what it set, the value now, and what
|
|
/// the one rebuild did (`coalesced`: how many steps it took). In the steps' order.
|
|
pub fn step_results(steps: &[Value], indices: &[usize], result: &Value) -> Vec<Value> {
|
|
let changed = result.get("changed").and_then(Value::as_object);
|
|
indices
|
|
.iter()
|
|
.map(|i| {
|
|
let set = steps.get(*i).and_then(plain_edit).unwrap_or_default();
|
|
let values: Map<String, Value> =
|
|
set.keys().map(|n| (n.clone(), changed.and_then(|c| c.get(n)).cloned().unwrap_or(Value::Null))).collect();
|
|
let mut r = json!({
|
|
"changed": values,
|
|
"coalesced": indices.len(),
|
|
"recomputed": result.get("recomputed").cloned().unwrap_or(Value::Null),
|
|
"restored": result.get("restored").cloned().unwrap_or(Value::Null),
|
|
"errors": result.get("errors").cloned().unwrap_or(Value::Null),
|
|
});
|
|
// A one-parameter step answers as `parameters.change {name, expression}` does.
|
|
if let (Some((name, e)), 1) = (set.iter().next(), set.len())
|
|
&& let Some(o) = r.as_object_mut()
|
|
{
|
|
o.insert("name".into(), json!(name));
|
|
o.insert("expression".into(), e.clone());
|
|
o.insert("value".into(), values.get(name).cloned().unwrap_or(Value::Null));
|
|
}
|
|
r
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn edit(name: &str, e: Value) -> Value {
|
|
json!({"command": "parameters.change", "params": {"name": name, "expression": e}})
|
|
}
|
|
|
|
#[test]
|
|
fn runs_of_plain_edits_join_and_anything_else_ends_them() {
|
|
let steps = vec![
|
|
edit("a", json!("2 mm")),
|
|
edit("b", json!(3)),
|
|
json!({"command": "solid.box", "params": {"length": 1, "width": 1, "height": 1}}),
|
|
edit("c", json!("4")),
|
|
json!({"id": "parameters.change", "params": {"changes": {"d": "5", "a": "6 mm"}}}),
|
|
edit("a", json!("7 mm")),
|
|
json!({"command": "parameters.change", "params": {"name": "e", "new_name": "f"}}),
|
|
edit("g", json!("1")),
|
|
];
|
|
let got = plan(&steps, true);
|
|
let mut changes = Map::new();
|
|
changes.insert("c".into(), json!("4"));
|
|
changes.insert("d".into(), json!("5"));
|
|
changes.insert("a".into(), json!("7 mm"));
|
|
let mut first = Map::new();
|
|
first.insert("a".into(), json!("2 mm"));
|
|
first.insert("b".into(), json!(3));
|
|
assert_eq!(
|
|
got,
|
|
vec![
|
|
BatchRun::Params { steps: vec![0, 1], changes: first },
|
|
BatchRun::Step(2),
|
|
BatchRun::Params { steps: vec![3, 4, 5], changes },
|
|
BatchRun::Step(6),
|
|
BatchRun::Step(7),
|
|
]
|
|
);
|
|
// Off (the default): every step on its own.
|
|
assert_eq!(plan(&steps, false), (0..steps.len()).map(BatchRun::Step).collect::<Vec<_>>());
|
|
}
|
|
|
|
#[test]
|
|
fn edits_with_more_than_a_name_and_an_expression_run_as_they_are() {
|
|
for params in [
|
|
json!({"name": "a", "expression": "1", "unit": "mm"}),
|
|
json!({"name": "a", "expression": "1", "comment": "x"}),
|
|
json!({"name": "a", "expression": [1]}),
|
|
json!({"delete": "a"}),
|
|
json!({"changes": {}}),
|
|
json!({"changes": {"a": "1"}, "unit": "mm"}),
|
|
json!({"name": " ", "expression": "1"}),
|
|
] {
|
|
let steps = vec![edit("b", json!("1")), json!({"command": "parameters.change", "params": params}), edit("c", json!("1"))];
|
|
assert_eq!(plan(&steps, true), vec![BatchRun::Step(0), BatchRun::Step(1), BatchRun::Step(2)], "{params}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn each_step_gets_its_own_result() {
|
|
let steps = vec![edit("a", json!("2 mm")), json!({"command": "parameters.change", "params": {"changes": {"b": "3", "c": "4"}}})];
|
|
let result = json!({"changed": {"a": 2.0, "b": 3.0, "c": 4.0}, "recomputed": 5, "restored": 0, "errors": []});
|
|
let rows = step_results(&steps, &[0, 1], &result);
|
|
assert_eq!(rows[0]["name"], "a");
|
|
assert_eq!(rows[0]["value"], 2.0);
|
|
assert_eq!(rows[0]["coalesced"], 2);
|
|
assert_eq!(rows[1]["changed"], json!({"b": 3.0, "c": 4.0}));
|
|
assert_eq!(rows[1]["recomputed"], 5);
|
|
assert!(rows[1].get("name").is_none());
|
|
}
|
|
}
|