SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Agent chat: tell the agent the design changed by hand since its last reply (#10854) (#11144)
Mateusz Sych06def2231d6e
diff --git a/crates/ui-egui/src/agent_chat/mod.rs b/crates/ui-egui/src/agent_chat/mod.rsindex 24966a7531..8ec1f9002a 100644--- a/crates/ui-egui/src/agent_chat/mod.rs+++ b/crates/ui-egui/src/agent_chat/mod.rs@@ -427,6 +427,9 @@ pub struct AgentChat {running_endpoint: String,backend: Option<Box<dyn ChatBackend>>,turn: Option<Turn>,+ /// The design as the agent last saw it: at the end of its last turn that it answered or worked+ /// in. The next message tells it when the design is no longer that one (#10854).+ seen: Option<Arc<solidcraft_engine::doc::Document>>,tools_available: Option<bool>,/// The latest completed turn's notice; older notices remain in the transcript.turn_warning: Option<String>,@@ -609,6 +612,8 @@ impl AgentChat {fn stop_backend(&mut self, wait: bool) {self.steering = false;+ // The next agent starts without this one's memory of the design.+ self.seen = None;if let Some(mut b) = self.backend.take() {b.cancel();b.shutdown(wait);@@ -1207,6 +1212,71 @@ const MAX_PENDING: usize = 20;/// Said to the agent before a message that interrupted it, so it knows its last step may be/// incomplete.const INTERRUPT_NOTE: &str = "[The user interrupted your previous step.]";+/// Most names one list of [`changed_note`] carries; the rest are counted.+const CHANGED_ITEMS: usize = 12;++/// Said to the agent before a message when the design is not the one its last turn left: the user+/// changed it by hand in between (#10854). Names the parameters and features that changed and+/// where the History marker went, so the agent reads the design again instead of reusing+/// positions and picks from before.+fn changed_note(seen: &solidcraft_engine::doc::Document, now: &solidcraft_engine::doc::Document) -> Option<String> {+ use solidcraft_engine::doc::Feature;+ use std::collections::HashMap;+ if seen == now {+ return None;+ }+ let clip = |s: &str| s.chars().take(60).collect::<String>();+ let list = |items: Vec<String>| {+ let more = items.len().saturating_sub(CHANGED_ITEMS);+ let mut text = items.into_iter().take(CHANGED_ITEMS).collect::<Vec<_>>().join(", ");+ if more > 0 {+ text.push_str(&format!(" and {more} more"));+ }+ text+ };+ let mut parts = Vec::new();+ let before: HashMap<&str, &str> = seen.params.iter().map(|p| (p.name.as_str(), p.expr.as_str())).collect();+ let after: HashMap<&str, &str> = now.params.iter().map(|p| (p.name.as_str(), p.expr.as_str())).collect();+ let params: Vec<String> = now+ .params+ .iter()+ .filter_map(|p| match before.get(p.name.as_str()) {+ Some(old) if *old == p.expr => None,+ Some(old) => Some(format!("{} {} -> {}", clip(&p.name), clip(old), clip(&p.expr))),+ None => Some(format!("{} = {} (new)", clip(&p.name), clip(&p.expr))),+ })+ .chain(seen.params.iter().filter(|p| !after.contains_key(p.name.as_str())).map(|p| format!("{} (removed)", clip(&p.name))))+ .collect();+ if !params.is_empty() {+ parts.push(format!("parameters: {}", list(params)));+ }+ let name = |f: &Feature| if f.name.is_empty() { format!("#{}", f.id) } else { clip(&f.name) };+ let before: HashMap<u64, &Feature> = seen.features.iter().map(|f| (f.id, f)).collect();+ let after: HashMap<u64, &Feature> = now.features.iter().map(|f| (f.id, f)).collect();+ let features: Vec<String> = now+ .features+ .iter()+ .filter_map(|f| match before.get(&f.id) {+ Some(old) if *old == f => None,+ Some(_) => Some(format!("{} (edited)", name(f))),+ None => Some(format!("{} (new)", name(f))),+ })+ .chain(seen.features.iter().filter(|f| !after.contains_key(&f.id)).map(|f| format!("{} (removed)", name(f))))+ .collect();+ if !features.is_empty() {+ parts.push(format!("features: {}", list(features)));+ }+ if seen.marker != now.marker {+ parts.push(match now.marker.and_then(|i| now.features.get(i)) {+ Some(f) => format!("the History marker is now before {}, so it and the features after it are rolled back", name(f)),+ None => "the History marker is now at the end".into(),+ });+ }+ let what = if parts.is_empty() { String::new() } else { format!(" ({})", parts.join("; ")) };+ Some(format!(+ "[The user changed the design by hand since your last reply{what}. Read it again before you reuse positions, edge or face picks or sizes from earlier in this chat.]"+ ))+}/// How many things the selection is, counting what was clicked (the two halves of a rim are one).pub fn selected_count(app: &mut SolveApp) -> usize {@@ -1412,6 +1482,7 @@ pub fn new_chat(app: &mut SolveApp) {chat.steering = false;chat.stopped = false;chat.ended = None;+ chat.seen = None;chat.discard_end = running;chat.model_revert = None;if matches!(chat.state(), State::Ready | State::Busy) {@@ -1457,15 +1528,15 @@ fn start_turn(app: &mut SolveApp, text: String, image: bool, at: Option<usize>,start_turn_with(app, text, image, at, files, None);}-/// Start a message; `note` goes before the text for the agent, not into the conversation. The+/// Start a message; `note` goes before the text for the agent, not into the conversation, and so+/// does what changed in the design since the agent's last turn ([`changed_note`]). The/// files are named after the text (text files in full), and pictures go as images to an agent/// that takes them. `at` is the message's place in the conversation, where its picture is kept.fn start_turn_with(app: &mut SolveApp, text: String, image: bool, at: Option<usize>, files: Vec<attach::Attachment>, note: Option<&str>) {let (pictures, documents) = (app.agent_chat.images, app.agent_chat.documents);- let lead = match note {- Some(n) => format!("{n}\n\n{text}"),- None => text.clone(),- };+ let changed = app.agent_chat.seen.as_deref().and_then(|seen| changed_note(seen, &app.session.doc));+ let notes: Vec<&str> = note.into_iter().chain(changed.as_deref()).collect();+ let lead = if notes.is_empty() { text.clone() } else { format!("{}\n\n{text}", notes.join("\n")) };// The whole message stays within the cap: the files' text gets what the words leave.let budget = MAX_PROMPT.saturating_sub(lead.chars().count() + FILE_NAMES_ROOM);let about_files = attach::note(&files, pictures, documents, budget);@@ -1739,6 +1810,10 @@ fn finish_turn(chat: &mut AgentChat, session: &mut solidcraft_engine::Session) {let Some(turn) = chat.turn.take() else { return };turn.active.store(false, std::sync::atomic::Ordering::Relaxed);let steps = merge_undo(&mut session.undo, &turn.start_doc, turn.start_undo, &trf("ui.agent_chat_undo_label", &[("message", &turn.label)]));+ // A turn the agent never answered (a sign-in, an error before its reply) showed it nothing.+ if turn.replied || turn.tool_called || turn.requests > 0 {+ chat.seen = Some(session.doc.clone());+ }if chat.ended.as_deref() == Some("")&& !chat.stopped&& turn.tools_availablediff --git a/crates/ui-egui/src/agent_chat/tests.rs b/crates/ui-egui/src/agent_chat/tests.rsindex 98f4c18f43..b5d3629163 100644--- a/crates/ui-egui/src/agent_chat/tests.rs+++ b/crates/ui-egui/src/agent_chat/tests.rs@@ -1386,6 +1386,77 @@ fn an_interrupted_turns_changes_undo_as_one_step() {assert!(Arc::ptr_eq(&app.session.doc, &before));}+/// What the user changes by hand between two messages is told to the agent before the next one,+/// with the parameters and features it touched (#10854): the agent built a hole on a parameter,+/// the user changed it, and the agent picked the old rim. Its own changes, and a design it has not+/// seen yet (a new chat), bring no note.+#[test]+fn a_change_by_hand_between_messages_is_told_to_the_agent() {+ use solidcraft_engine::doc::Param;+ let (mut app, script, ctx) = app_with_script();+ let (tx, rx) = channel();+ app.agent_chat.tools_rx = Some(rx);+ app.agent_chat.attach_selection = false;+ let expr = |app: &SolveApp| app.session.doc.params.iter().find(|p| p.name == "w").map(|p| p.expr.clone()).unwrap();++ send(&mut app, &ctx, "a box and a parameter w".into());+ let replies = [+ ask(&tx, "engine.execute", json!({"command": "parameters.add", "params": {"name": "w", "expression": "10", "unit": "mm"}})),+ ask(&tx, "engine.execute", boxed(0.0)),+ ];+ frame(&mut app);+ for r in replies {+ assert_eq!(r.recv_timeout(std::time::Duration::from_secs(30)).unwrap()["ok"], true);+ }+ ended(&script, "");+ poll(&mut app, &ctx);+ send(&mut app, &ctx, "thanks".into());+ assert_eq!(script.calls().last().map(String::as_str), Some("prompt: thanks"), "the agent made those changes itself");+ ended(&script, "");+ poll(&mut app, &ctx);++ let old = expr(&app);+ app.run("parameters.change", json!({"name": "w", "expression": "25"})).unwrap();+ app.run("solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [30, 0, 0]})).unwrap();+ let added = app.session.doc.features.last().map(|f| f.name.clone()).unwrap();+ send(&mut app, &ctx, "chamfer it".into());+ let sent = text_of(script.prompts().last().unwrap());+ // The new box may bring parameters of its own after `w`.+ let new = expr(&app);+ assert!(sent.starts_with(&format!("[The user changed the design by hand since your last reply (parameters: w {old} -> {new}")), "{sent}");+ assert!(sent.contains(&format!("; features: {added} (new)). Read it again before")), "{sent}");+ assert!(sent.ends_with("chat.]\n\nchamfer it"), "{sent}");+ assert!(+ matches!(app.agent_chat.items.iter().rev().find(|i| matches!(i, Item::User { .. })), Some(Item::User { text, .. }) if text == "chamfer it")+ );+ script.report(Event::Text { thought: false, text: "done".into() });+ ended(&script, "");+ poll(&mut app, &ctx);+ send(&mut app, &ctx, "and again".into());+ assert_eq!(script.calls().last().map(String::as_str), Some("prompt: and again"), "told once");+ ended(&script, "");+ poll(&mut app, &ctx);++ // The note's other parts, and its bound on what it lists.+ let seen = app.session.doc.as_ref().clone();+ assert!(changed_note(&seen, &seen.clone()).is_none());+ let mut rolled = seen.clone();+ rolled.marker = Some(0);+ let first = seen.features.first().map(|f| f.name.clone()).unwrap();+ assert!(changed_note(&seen, &rolled).unwrap().contains(&format!("(the History marker is now before {first}, so it")));+ let mut many = seen.clone();+ let w = seen.params.iter().find(|p| p.name == "w").cloned().unwrap();+ many.params.extend((0..20).map(|i| Param { name: format!("p{i}"), ..w.clone() }));+ assert!(changed_note(&seen, &many).unwrap().contains(&format!(", p11 = {} (new) and 8 more)", w.expr)));++ // A new chat starts a session that has seen nothing.+ app.run("parameters.change", json!({"name": "w", "expression": "30"})).unwrap();+ new_chat(&mut app);+ app.agent_chat.state = Some(State::Ready);+ send(&mut app, &ctx, "hello".into());+ assert_eq!(script.calls().last().map(String::as_str), Some("prompt: hello"));+}+/// The same with a real agent process speaking ACP: `session/cancel` goes out, the agent answers/// the held prompt with the cancelled stop reason, and only then does the queued text go as a new/// `session/prompt`.diff --git a/docs/agent-chat.md b/docs/agent-chat.mdindex 7cab2d0966..207d9d7e2b 100644--- a/docs/agent-chat.md+++ b/docs/agent-chat.md@@ -185,6 +185,13 @@ messages go as one prompt, in order, when the turn ends normally.fresh session on the same agent, keeping the agent and its mode. It asks first when a messageis running or queued, or files are waiting. The design's undo history is untouched.+When you change the design yourself between two messages (a parameter, a feature, an undo, the+History marker), your next message tells the agent so first, in a short note the conversation+doesn't show: which parameters changed and from what to what, which features are new, edited or+removed, and where the History marker went. The note asks the agent to read the design again+instead of picking edges and faces where they were before. A new chat or a new agent session has+seen nothing yet, so its first message carries no note.+## AgentsPreferences → AI → **Agents** lists every agent the chat can use, each with its kind (a program or