Agent commands compute off the window thread, so the window stays live (opt-in) (#1989) (#3340)

An agent's design changes over the control channel (engine.execute, engine.batch) are evaluated
ahead on a copy of the session on an `agent` worker, then run on the window thread reusing every
feature computed there (doc::KeptResults, whatever the bounded evaluation cache dropped); the
worker also makes the display meshes of the bodies they end with. Exports run on a copy. While a
change computes, or the agent cursor acts one out, ui.*, inspection and screenshots answer; later
design changes wait their turn. A chip names the command with Stop. A person's edit meanwhile goes
first; a replaced design refuses the request. Preference: Preferences > AI, agent_off_thread, off
by default.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
SS-EN
2026-10-21 00:58:56 +00:00
committed by GitHub
parent 79a843c963
commit 776541b081
15 changed files with 923 additions and 50 deletions
+2
View File
@@ -1209,6 +1209,8 @@
"ui.agent_chat_view_attached": "View attached",
"ui.agent_cursor": "Agent cursor",
"ui.agent_cursor_speed": "Agent cursor speed",
"ui.agent_off_thread": "Keep the window responsive while agents run commands",
"ui.agent_off_thread_note": "An agent's slow commands (from the AI panel or an MCP client) compute beside the window: you can keep turning and inspecting the view, and stop one from the chip in the view. Off: each runs on the window's thread and the window waits for it.",
"ui.ai_add": "Add",
"ui.ai_add_agent": "Add agent…",
"ui.ai_add_agent_title": "Add agent",
+2
View File
@@ -1209,6 +1209,8 @@
"ui.agent_chat_view_attached": "ビューを添付済み",
"ui.agent_cursor": "エージェントカーソル",
"ui.agent_cursor_speed": "エージェントカーソル速度",
"ui.agent_off_thread": "エージェントのコマンド実行中もウィンドウを操作可能にする",
"ui.agent_off_thread_note": "エージェント(AI パネルまたは MCP クライアント)の時間のかかるコマンドをウィンドウとは別に計算します。実行中もビューの回転や確認ができ、ビュー内の表示から停止できます。オフ:各コマンドはウィンドウのスレッドで実行され、終わるまでウィンドウは待ちます。",
"ui.ai_add": "追加",
"ui.ai_add_agent": "エージェントを追加…",
"ui.ai_add_agent_title": "エージェントを追加",
+2
View File
@@ -1209,6 +1209,8 @@
"ui.agent_chat_view_attached": "已附加视图",
"ui.agent_cursor": "代理光标",
"ui.agent_cursor_speed": "代理光标速度",
"ui.agent_off_thread": "代理运行命令时保持窗口响应",
"ui.agent_off_thread_note": "代理(来自 AI 面板或 MCP 客户端)的耗时命令在窗口之外计算:运行时仍可旋转和查看视图,并可在视图中的提示上停止它。关闭:每条命令在窗口线程上运行,窗口会等待其完成。",
"ui.ai_add": "添加",
"ui.ai_add_agent": "添加智能体…",
"ui.ai_add_agent_title": "添加智能体",
+90 -15
View File
@@ -777,6 +777,48 @@ impl EvalCache {
}
}
/// The results an evaluation ahead on a copy of a model computed or took from the cache, kept for
/// the run that follows on the model itself (#1989). The evaluation cache is bounded by bytes and
/// charges every entry its whole model, so on a design with large bodies it holds only the last
/// few states: by the time the run came, the cache had dropped most of what was computed ahead,
/// and the run computed it all again, on the window thread.
#[derive(Debug, Default)]
pub struct KeptResults(std::sync::Mutex<std::collections::HashMap<u64, CachedEval>>);
impl KeptResults {
/// Results kept.
pub fn len(&self) -> usize {
self.0.lock().map_or(0, |m| m.len())
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
fn get(&self, key: u64) -> Option<CachedEval> {
self.0.lock().ok().and_then(|m| m.get(&key).cloned())
}
fn put(&self, key: u64, e: &CachedEval) {
if let Ok(mut m) = self.0.lock()
&& (m.len() < CACHE_ENTRIES || m.contains_key(&key))
{
m.insert(key, e.clone());
}
}
}
/// Where a model keeps its results besides the cache ([`Model::keep`]). A copy of the model
/// starts without: it keeps nothing it computes for someone else's run.
#[derive(Debug, Default)]
struct KeptSlot(Option<Arc<KeptResults>>);
impl Clone for KeptSlot {
fn clone(&self) -> Self {
KeptSlot(None)
}
}
impl SolvedSketch {
/// Rough heap footprint (see [`ModelState::retained_bytes`]).
pub fn retained_bytes(&self) -> usize {
@@ -810,6 +852,14 @@ impl ModelState {
}
});
}
/// [`ModelState::warm_meshes`], and every body's display plan at the current display quality
/// (what a GPU viewport draws).
pub fn warm_display(&self) {
kernel::for_each_on_threads(&self.bodies, 16, |b| {
let _ = b.mesh();
let _ = b.display_plan();
});
}
pub fn sketch(&self, feature: u64) -> Option<&SolvedSketch> {
self.sketches.iter().find(|s| s.feature == feature).map(|s| &**s)
}
@@ -844,6 +894,9 @@ pub struct Model {
empty: Arc<ModelState>,
/// Features recomputed by the last `evaluate`.
pub last_recomputed: usize,
/// Features recomputed by every `evaluate` of this model (and of the model it was copied
/// from) so far.
pub recomputed: usize,
/// Features whose result the last `evaluate` took from the cache instead of recomputing: the
/// same feature on the same inputs was evaluated before (an edit set back, undo, redo, a
/// configuration row). Their geometry did change since the previous evaluation.
@@ -852,6 +905,8 @@ pub struct Model {
pub cache: Arc<std::sync::Mutex<EvalCache>>,
/// Evaluate everything from scratch (no reuse; tests compare the two).
pub no_cache: bool,
/// Results kept besides the cache ([`Model::keep`]).
kept: KeptSlot,
/// The imported texts' digests the last `evaluate` fingerprinted the features with.
step_digests: StepDigests,
}
@@ -1295,6 +1350,20 @@ impl Model {
})
}
/// While `kept` is set, every result this model evaluates or takes from the cache is also
/// kept there, and a result the cache no longer has is taken from there (#1989): an
/// evaluation ahead on a copy keeps what it computes, and the run that follows on the model
/// itself finds it all, whatever the cache dropped meanwhile. Copies of the model keep
/// nothing.
pub fn keep(&mut self, kept: Option<Arc<KeptResults>>) {
self.kept = KeptSlot(kept);
}
/// Where this model keeps its results besides the cache, if it does ([`Model::keep`]).
pub fn kept(&self) -> Option<Arc<KeptResults>> {
self.kept.0.clone()
}
/// Whether the results are `doc`'s evaluation: one per feature, each on the inputs `doc`
/// gives it, none stale, so [`Model::evaluate`] would keep every one of them. A document
/// changed without an evaluation since is not.
@@ -1368,9 +1437,13 @@ impl Model {
}
// The same feature on the same inputs: its earlier result.
let key = cache_key(f, fp, fingerprint(0, f, &vals, false, &self.step_digests) ^ placement_digest(doc, f), ctx, &state);
let kept = self.kept.0.as_ref().filter(|_| !self.no_cache);
if !self.no_cache
&& let Some(c) = self.cache.lock().ok().and_then(|mut m| m.get(key))
&& let Some(c) = self.cache.lock().ok().and_then(|mut m| m.get(key)).or_else(|| kept.and_then(|k| k.get(key)))
{
if let Some(k) = kept {
k.put(key, &c);
}
restored += 1;
if c.error.is_none() {
state = c.state.clone();
@@ -1499,20 +1572,21 @@ impl Model {
}
Err(e) => Some(e.to_string().trim_start_matches("the operation failed: ").to_string()),
};
if !self.no_cache
&& let Ok(mut m) = self.cache.lock()
{
m.put(
key,
CachedEval {
error: error.clone(),
warning: warning.clone(),
boolean_diagnostics: boolean_diagnostics.clone(),
ms,
bytes: state.retained_bytes(),
state: state.clone(),
},
);
if !self.no_cache {
let e = CachedEval {
error: error.clone(),
warning: warning.clone(),
boolean_diagnostics: boolean_diagnostics.clone(),
ms,
bytes: state.retained_bytes(),
state: state.clone(),
};
if let Some(k) = &self.kept.0 {
k.put(key, &e);
}
if let Ok(mut m) = self.cache.lock() {
m.put(key, e);
}
}
out.push(FeatureResult {
id: f.id,
@@ -1529,6 +1603,7 @@ impl Model {
}
self.results = out;
self.last_recomputed = recomputed;
self.recomputed += recomputed;
self.last_restored = restored;
}
}
+1
View File
@@ -57,6 +57,7 @@ pub use assembly::{
rigid,
};
pub use document::*;
pub use eval::KeptResults;
pub use eval::{
EdgeRef, FeatureResult, Model, ModelBody, ModelState, PlacedBodies, RevolveExtent, SavedModel, SolvedSketch, ThreadInfo, curve_pick_error,
edge_names_for, edge_refs, face_point_names, face_point_state, hole_direction_at, import_body_names, metric_thread_sizes, object_height,
+22
View File
@@ -103,6 +103,28 @@ fn set_back_reports_restored_features() {
assert_eq!((m.last_recomputed, m.last_restored), (0, 0));
}
/// #1989: what an evaluation ahead on a copy of the model computed is kept for the run that
/// follows on the model itself, which finds it there even once the evaluation cache has dropped
/// it (the cache keeps only a few states of a design with large bodies). Copies keep nothing.
#[test]
fn results_kept_ahead_outlive_the_cache() {
let (mut doc, _) = plate_doc();
let mut m = Model::new();
m.evaluate(&doc);
doc.set_param("width", "50 mm", None, None).unwrap();
let kept = std::sync::Arc::new(KeptResults::default());
let mut ahead = m.clone();
ahead.keep(Some(kept.clone()));
assert!(ahead.clone().kept().is_none(), "a copy keeps nothing");
ahead.evaluate(&doc);
assert_eq!((ahead.last_recomputed, kept.len()), (2, 2));
*m.cache.lock().unwrap() = Default::default();
m.keep(Some(kept));
m.evaluate(&doc);
assert_eq!((m.last_recomputed, m.last_restored), (0, 2), "nothing computed again");
assert!(rel(measure(&m.state().bodies[0].body).unwrap().volume, 30000.0) < 1e-9);
}
#[test]
fn box_fillet_cut_timeline() {
let (mut doc, _) = plate_doc();
+13 -2
View File
@@ -170,9 +170,19 @@ pub struct Snapshot {
pub struct Ahead(Session);
impl Ahead {
/// Run `commands` (their results stay in the shared evaluation cache).
/// What the evaluation computes, kept for the run that follows here whatever the evaluation
/// cache drops meanwhile: hand it to [`solidcraft_doc::Model::keep`] for that run.
pub fn kept(&self) -> Arc<solidcraft_doc::KeptResults> {
self.0.model.kept().unwrap_or_default()
}
/// Run `commands` (their results stay in the shared evaluation cache, and in [`Ahead::kept`]),
/// then make the display meshes and plans of the bodies they end with: the bodies the run
/// here finds share them, so the window draws, fits and picks without tessellating anything.
pub fn evaluate(self, commands: &[(String, Value)]) -> Result<()> {
self.0.preview_in_place(commands).map(|_| ())
let (s, _) = self.0.preview_in_place(commands)?;
s.world_state().warm_display();
Ok(())
}
/// Run `commands` one after another, each reply or error in turn (what they evaluate stays
@@ -1030,6 +1040,7 @@ impl Session {
let mut copy = self.scratch();
copy.undo.clone_from(&self.undo);
copy.redo.clone_from(&self.redo);
copy.model.keep(Some(Arc::default()));
Ahead(copy)
}
@@ -110,6 +110,10 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
ui_kit::text(ui, tr("ui.agent_chat_desktop_only"), ui_kit::Text::Note("desktop"));
return;
}
// Any agent's control requests, the chat's or an outside MCP client's (#1989).
let r = ui_kit::checkbox(ui, tr("ui.agent_off_thread"), &mut app.preferences.agent_off_thread);
crate::scenario::publish_handle("prefs:agent_off_thread", r.rect.center());
ui_kit::text(ui, tr("ui.agent_off_thread_note"), ui_kit::Text::Note("off_thread"));
if !app.preferences.ai_features {
return;
}
+26 -4
View File
@@ -140,6 +140,9 @@ pub struct Job {
started: f64,
/// Clicked at the current stop (waiting out the click).
clicked: bool,
/// The command computing ahead off the window thread while the pointer glides (#1989): at
/// its last stop the pointer waits for it, then the command runs and finds it in the cache.
ahead: Option<crate::control_job::Ahead>,
}
/// The pointer's state.
@@ -158,6 +161,19 @@ impl AgentCursor {
pub fn busy(&self) -> bool {
self.job.is_some()
}
/// Since when the pointer has waited at its last stop for its command to compute (ms), and
/// the command.
pub fn computing(&self) -> Option<(f64, &str)> {
self.job.as_ref().filter(|j| j.stops.is_empty()).and_then(|j| j.ahead.as_ref()).map(|a| (a.started, a.label.as_str()))
}
/// Stop the request the pointer waits on: answered as stopped, nothing of it applied.
pub(crate) fn stop(&mut self) -> Option<(Sender<ControlResponse>, String)> {
self.computing()?;
let job = self.job.take()?;
Some((job.reply, job.ahead.map(|a| a.label).unwrap_or_default()))
}
}
/// Most picks the pointer visits for one command, besides its toolbar button. More are
@@ -324,6 +340,8 @@ pub fn intercept(app: &mut SolveApp, method: &str, params: &Value, reply: &Sende
return false;
}
let from = app.cursor_start();
// Computed ahead (a command or a batch's steps) while the pointer glides (#1989).
let ahead = crate::control_job::Ahead::begin(app, method, params);
let (glide, click) = leg_times(s.speed, stops.len());
app.agent.job = Some(Job {
method: method.to_string(),
@@ -335,6 +353,7 @@ pub fn intercept(app: &mut SolveApp, method: &str, params: &Value, reply: &Sende
from,
started: app.now,
clicked: false,
ahead,
});
true
}
@@ -362,7 +381,9 @@ pub fn step(app: &mut SolveApp, ctx: &egui::Context) {
let (glide, click) = (job.glide, job.click);
ctx.request_repaint();
let Some(&to) = job.stops.front() else {
finish(app, ctx);
if job.ahead.as_ref().is_none_or(crate::control_job::Ahead::finished) {
finish(app, ctx);
}
return;
};
let t = if glide > 0.0 { (now - job.started) / glide } else { 1.0 };
@@ -381,7 +402,7 @@ pub fn step(app: &mut SolveApp, ctx: &egui::Context) {
job.from = to;
job.started = now;
job.clicked = false;
if job.stops.is_empty() {
if job.stops.is_empty() && job.ahead.as_ref().is_none_or(crate::control_job::Ahead::finished) {
finish(app, ctx);
}
}
@@ -399,10 +420,11 @@ fn finish(app: &mut SolveApp, ctx: &egui::Context) {
app.agent.saved_view = Some(app.cam);
}
let (req, _rx) = crate::control::ControlRequest::new(job.method, params);
let out = match crate::control::handle(app, ctx, &req) {
// What was computed ahead while the pointer glided is found rather than computed again here.
let out = app.run_with_kept(job.ahead.map(|a| a.kept), |app| match crate::control::handle(app, ctx, &req) {
crate::control::Outcome::Done(v) => v,
crate::control::Outcome::Screenshot { .. } => json!({"ok": false, "error": "not a command"}),
};
});
let ran = out.get("ok").and_then(Value::as_bool).unwrap_or(false);
if follow && ran {
if id == "sketch.create" {
+394
View File
@@ -0,0 +1,394 @@
//! Control-channel (MCP) requests that compute off the window thread (#1989): an agent's slow
//! command (a boolean, a fillet, a big batch, an export) used to run on the window thread, and
//! the window froze until it was done: no redraw, no orbit, no way to stop it.
//!
//! The window thread still owns the design. What leaves it is the computing:
//! - **Design changes** (`engine.execute` of a modelling command, `engine.batch`) are evaluated
//! ahead on a copy of the session ([`solidcraft_engine::Session::ahead`]), as the history
//! marker and undo are ([`crate::deferred`]). What that computes is kept
//! ([`solidcraft_engine::doc::KeptResults`]); once it is in, the request runs here for real, as
//! it always did (undo step, recovery autosave, crash journal, agent cursor, reply), and finds
//! every feature it computed there, whatever the bounded evaluation cache dropped meanwhile.
//! One design change computes at a time; later ones wait their turn, in order.
//! - **Exports** (`file.export`, `file.save_mesh`) change nothing in the design: they run on a
//! copy of it as it was when they were asked for, and their reply comes from there. Nothing
//! waits behind them.
//!
//! Meanwhile the window goes on drawing the design as it was, `ui.*` requests and inspection are
//! answered, and a chip says which agent command is computing, with a Stop button. A person's
//! own edits meanwhile go first: the agent's command is then computed again for the design as it
//! is and lands after them, never in between. If the design itself was replaced (another tab, a
//! file opened) the agent's command is refused, saying so, and nothing is applied.
//!
//! Done within the app's wait ([`crate::dialogs::APPLY_AT_ONCE`]), a request just runs, as
//! before. Headless use, tests and the web build ([`SolveApp::apply_off_thread`] unset) run
//! everything at once, and so does the app unless the preference is on (Preferences > AI,
//! `agent_off_thread`, off by default).
use std::sync::Arc;
use std::sync::mpsc::{Receiver, TryRecvError};
use serde_json::{Value, json};
use solidcraft_engine::doc::KeptResults;
use crate::SolveApp;
use crate::control::ControlRequest;
/// Areas whose commands only compute the design (no files written, nothing started outside the
/// app), so evaluating them ahead on a copy has no effect but a warm cache.
const AHEAD_AREAS: [&str; 22] = [
"appearance",
"assembly",
"body",
"component",
"config",
"construct",
"contact",
"explode",
"expr",
"face",
"joint",
"material",
"mesh",
"model",
"occurrence",
"parameters",
"plastic",
"sheet",
"sketch",
"solid",
"surface",
"timeline",
];
/// Parameters that name a file or folder: a command given one runs here, as before.
const NAMES_A_FILE: [&str; 8] = ["path", "paths", "file", "files", "dir", "folder", "url", "out"];
/// Commands that change nothing in the design and write a file: they run on a copy.
const ANSWERED_ON_A_COPY: [&str; 2] = ["file.export", "file.save_mesh"];
/// Exports computing at once; more run here.
const MAX_ANSWERING: usize = 4;
/// How often a design change is computed again because the design changed under it before it
/// runs here anyway.
const MAX_TRIES: u8 = 3;
/// The command's own id (as registered), if it has one.
fn spec_id(command: &str) -> Option<&'static str> {
solidcraft_engine::find_command(command).map(|c| c.id)
}
fn names_a_file(params: &Value) -> bool {
params.as_object().is_some_and(|o| o.keys().any(|k| NAMES_A_FILE.contains(&k.as_str())))
}
/// Can `command` be evaluated ahead on a copy of the session with no effect outside it?
pub(crate) fn computes_ahead(command: &str, params: &Value) -> bool {
let Some(id) = spec_id(command) else { return false };
if matches!(id, "edit.undo" | "edit.redo") {
return true;
}
let area = id.split('.').next().unwrap_or_default();
AHEAD_AREAS.contains(&area) && !["export", "import", "save", "library"].iter().any(|w| id.contains(w)) && !names_a_file(params)
}
/// The command an `engine.execute` request (its `params`) runs and its parameters.
fn executed(params: &Value) -> Option<(&str, Value)> {
let command = params.get("command").or_else(|| params.get("id")).and_then(Value::as_str)?;
Some((command, params.get("params").cloned().filter(|v| !v.is_null()).unwrap_or(json!({}))))
}
/// Requests that change the design: they wait while one computes.
pub(crate) fn changes_the_design(method: &str) -> bool {
matches!(method, "engine.execute" | "command" | "engine.script" | "engine.batch")
}
/// What a request computes off the window thread.
enum Work {
/// Evaluated ahead: once in, the request runs here. `doc` and `revision` are the design it
/// was computed for.
Ahead { commands: Vec<(String, Value)>, doc: Arc<solidcraft_engine::doc::Document>, revision: u64, tries: u8, kept: Arc<KeptResults> },
/// Run on a copy; the reply comes from there.
Answer,
}
/// A control request computing off the window thread.
pub struct ControlJob {
req: ControlRequest,
work: Work,
/// The worker's result: `Some` reply for [`Work::Answer`].
done: Receiver<Option<Value>>,
/// When it was asked for (ms).
pub(crate) started: f64,
/// The command, as the toolbar names it.
pub(crate) label: String,
}
impl ControlJob {
fn poll(&self) -> Option<Option<Value>> {
match self.done.try_recv() {
Ok(r) => Some(r),
Err(TryRecvError::Disconnected) => Some(None),
Err(TryRecvError::Empty) => None,
}
}
}
fn label(app: &SolveApp, command: &str) -> String {
let language = crate::i18n::Locale::for_language(&app.preferences.language);
language.label(solidcraft_engine::find_command(command).map_or(command, |c| c.label)).to_string()
}
/// Run `f` on a worker thread (with the request's folder scope), answering on the returned
/// channel. `None` without threads (the web).
fn spawn(
scope: Option<solidcraft_engine::io::vfs::PathScope>,
f: impl FnOnce() -> Option<Value> + Send + 'static,
) -> Option<Receiver<Option<Value>>> {
let (tx, rx) = std::sync::mpsc::channel();
std::thread::Builder::new()
.name("agent".into())
.spawn(move || {
let r = solidcraft_engine::io::vfs::scoped(scope, f);
let _ = tx.send(r);
})
.ok()?;
Some(rx)
}
/// Evaluate `commands` ahead on a copy of the session, on a worker (with the folder scope
/// `request` names). What it computes is kept for the run here.
fn evaluate_ahead(app: &SolveApp, request: &Value, commands: Vec<(String, Value)>) -> Option<(Receiver<Option<Value>>, Arc<KeptResults>)> {
let scope = crate::control::request_scope(app, request).ok()?;
let ahead = app.session.ahead();
let kept = ahead.kept();
let rx = spawn(scope, move || {
let _ = ahead.evaluate(&commands);
None
})?;
Some((rx, kept))
}
/// Start computing a design change ahead, for the design as it is now.
fn begin_ahead(app: &SolveApp, req: &ControlRequest, commands: Vec<(String, Value)>, tries: u8) -> Option<(Work, Receiver<Option<Value>>)> {
let (rx, kept) = evaluate_ahead(app, &req.params, commands.clone())?;
Some((Work::Ahead { commands, doc: app.session.doc.clone(), revision: app.session.revision, tries, kept }, rx))
}
impl SolveApp {
/// Run a control request here with what was computed ahead for it at hand ([`KeptResults`]):
/// its features are found there rather than computed again on the window thread.
pub(crate) fn run_with_kept<R>(&mut self, kept: Option<Arc<KeptResults>>, run: impl FnOnce(&mut SolveApp) -> R) -> R {
let keeps = kept.is_some();
if keeps {
self.session.model.keep(kept);
}
let r = run(self);
if keeps {
self.session.model.keep(None);
}
r
}
}
/// A command the agent cursor acts out, evaluating ahead while the pointer glides to it.
pub struct Ahead {
done: Receiver<Option<Value>>,
/// What it computes, for the run once the pointer is there.
pub(crate) kept: Arc<KeptResults>,
/// When it started (ms).
pub(crate) started: f64,
/// The command, as the toolbar names it.
pub(crate) label: String,
}
impl Ahead {
/// Start evaluating the design changes of the `request` (`method`: an `engine.execute` or an
/// `engine.batch`) the pointer acts out; `None` when it just runs once the pointer is there
/// (not computed off the window thread, or nothing to compute).
pub(crate) fn begin(app: &SolveApp, method: &str, request: &Value) -> Option<Ahead> {
app.apply_off_thread?;
if !app.preferences.agent_off_thread || app.file_load.busy() || app.file_picker.is_some() {
return None;
}
let commands = ahead_commands(method, request);
let label = label(app, &commands.first()?.0);
let (done, kept) = evaluate_ahead(app, request, commands)?;
Some(Ahead { done, kept, started: crate::now_ms(), label })
}
/// The evaluation is in (or its worker ended).
pub(crate) fn finished(&self) -> bool {
!matches!(self.done.try_recv(), Err(TryRecvError::Empty))
}
}
/// The design changes a request (`method`, `params`) would make that can be computed ahead: an
/// `engine.execute` of such a command, or the steps of a batch up to the first that can't.
/// Empty: it just runs.
fn ahead_commands(method: &str, p: &Value) -> Vec<(String, Value)> {
match method {
"engine.execute" | "command" => match executed(p) {
Some((command, params)) if computes_ahead(command, &params) => vec![(command.to_string(), params)],
_ => Vec::new(),
},
"engine.batch" => {
// Timings measure the run here: it must do the work.
if ["timings", "profile"].iter().any(|k| p.get(*k).and_then(Value::as_bool) == Some(true)) {
return Vec::new();
}
let Some(steps) = p.get("commands").and_then(Value::as_array) else { return Vec::new() };
steps
.iter()
.map_while(|step| {
let command = step.get("command").or_else(|| step.get("id")).and_then(Value::as_str)?;
let params = step.get("params").cloned().filter(|v| !v.is_null()).unwrap_or(json!({}));
computes_ahead(command, &params).then(|| (command.to_string(), params))
})
.collect()
}
_ => Vec::new(),
}
}
/// Wait the app's wait for a worker: `Some(result)` when it finished within it.
fn within_wait(app: &SolveApp, rx: &Receiver<Option<Value>>) -> Option<Option<Value>> {
let wait = app.apply_off_thread?;
if wait.is_zero() {
return None;
}
match rx.recv_timeout(wait) {
Ok(r) => Some(r),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => Some(None),
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => None,
}
}
impl SolveApp {
/// Since when an agent's design change has been computing off the window thread (ms), and
/// its command.
pub fn agent_computing(&self) -> Option<(f64, &str)> {
self.control_job.as_ref().map(|j| (j.started, j.label.as_str())).or_else(|| self.agent.computing())
}
/// Stop waiting for the agent's design change that is computing: it is answered as stopped
/// and nothing of it is applied (its worker finishes on its own, unseen). Requests waiting
/// behind it go on.
pub fn stop_agent_command(&mut self) {
let stopped = match self.control_job.take() {
Some(job) => Some((job.req.reply, job.label)),
None => self.agent.stop(),
};
if let Some((reply, label)) = stopped {
let _ = reply.send(json!({
"ok": false,
"stopped": true,
"error": format!("stopped: the person at the app stopped `{label}` while it computed; nothing was applied"),
}));
}
}
/// Take a control request off the window thread when it computes long (see the module
/// notes). Returns it when it should simply run here now.
pub(crate) fn offload_control(&mut self, ctx: &egui::Context, req: ControlRequest) -> Option<ControlRequest> {
if self.apply_off_thread.is_none() || !self.preferences.agent_off_thread || self.file_load.busy() || self.file_picker.is_some() {
return Some(req);
}
// An export: on a copy, answered from there.
if matches!(req.method.as_str(), "engine.execute" | "command")
&& self.control_answering.len() < MAX_ANSWERING
&& let Some((command, params)) = executed(&req.params)
&& let Some(id) = spec_id(command).filter(|id| ANSWERED_ON_A_COPY.contains(id))
{
let Ok(scope) = crate::control::request_scope(self, &req.params) else { return Some(req) };
let mut copy = self.session.scratch();
let rx = spawn(scope, move || {
Some(match copy.execute(id, &params) {
Ok(v) => json!({"ok": true, "result": v}),
Err(e) => json!({"ok": false, "error": e.to_string()}),
})
});
let Some(rx) = rx else { return Some(req) };
let job = ControlJob { label: label(self, id), req, work: Work::Answer, done: rx, started: crate::now_ms() };
match within_wait(self, &job.done) {
Some(reply) => self.answered(job, reply),
None => self.control_answering.push(job),
}
return None;
}
let commands = ahead_commands(&req.method, &req.params);
let Some(first) = commands.first().map(|(c, _)| c.clone()) else { return Some(req) };
let Some((work, rx)) = begin_ahead(self, &req, commands, 0) else { return Some(req) };
let job = ControlJob { label: label(self, &first), req, work, done: rx, started: crate::now_ms() };
if within_wait(self, &job.done).is_some() {
// Computed within the wait: it runs now, as before, finding what was computed.
let Work::Ahead { kept, .. } = job.work else { return Some(job.req) };
self.run_with_kept(Some(kept), |app| app.run_control(ctx, job.req));
return None;
}
self.control_job = Some(job);
None
}
/// An export's reply, from its copy, with the echo the command leaves when it runs here.
fn answered(&mut self, job: ControlJob, reply: Option<Value>) {
let reply = reply.unwrap_or_else(|| json!({"ok": false, "error": format!("`{}` ended without a reply", job.label)}));
if reply["ok"] == true {
let language = crate::i18n::Locale::for_language(&self.preferences.language);
self.session.echo(language.format("ui.command_done", &[("command", job.label.as_str())]));
}
let _ = job.req.reply.send(reply);
}
/// Each frame: exports that are done reply; a design change whose evaluation is in runs.
pub(crate) fn poll_control_jobs(&mut self, ctx: &egui::Context) {
if !self.control_answering.is_empty() {
let mut i = 0;
while i < self.control_answering.len() {
match self.control_answering.get(i).and_then(ControlJob::poll) {
Some(reply) => {
let job = self.control_answering.remove(i);
self.answered(job, reply);
}
None => i += 1,
}
}
ctx.request_repaint_after(std::time::Duration::from_millis(100));
}
let Some(job) = &self.control_job else { return };
if job.poll().is_none() {
ctx.request_repaint_after(std::time::Duration::from_millis(100));
return;
}
let Some(job) = self.control_job.take() else { return };
// A file opening meanwhile: the request waits for it as any design change does.
if self.file_load.busy() || self.file_picker.is_some() {
self.control_held.push_front(job.req);
return;
}
let Work::Ahead { commands, doc, revision, tries, kept } = job.work else { return };
let s = &self.session;
let same = Arc::ptr_eq(&s.doc, &doc);
// The design it was computed for is still this one, edited since (an undo step away).
let edited = !same && s.undo.iter().chain(&s.redo).any(|snap| Arc::ptr_eq(&snap.doc, &doc));
if !same && !edited {
let _ = job.req.reply.send(json!({
"ok": false,
"error": format!("the design was replaced (another tab, or a file opened) while `{}` computed; nothing was applied", job.label),
}));
return;
}
if (!same || s.revision != revision) && tries < MAX_TRIES {
// A person's edit went first: computed again for the design as it is now.
if let Some((work, rx)) = begin_ahead(self, &job.req, commands, tries + 1) {
self.control_job = Some(ControlJob { work, done: rx, ..job });
return;
}
}
self.big_operation |= crate::now_ms() - job.started >= crate::recovery_ui::BIG_OPERATION_MS;
self.run_with_kept(Some(kept), |app| app.run_control(ctx, job.req));
ctx.request_repaint();
}
}
+253 -1
View File
@@ -1,6 +1,7 @@
//! Commands that recompute the history off the window thread (`deferred`): the marker moved,
//! undo, each computed beside the window and run once in; a marker moved again while one move
//! computes replaces the move still waiting.
//! computes replaces the move still waiting. And an agent's control requests (`control_job`,
//! #1989): its design changes computed beside the window, in order, while the window answers.
use std::time::Duration;
@@ -99,6 +100,257 @@ fn a_design_changed_while_a_move_computes_is_computed_again() {
assert_eq!(marker(&h), Some(2));
}
/// A control request for the app, and where its reply lands.
fn ask(tx: &std::sync::mpsc::Sender<crate::ControlRequest>, method: &str, params: serde_json::Value) -> std::sync::mpsc::Receiver<serde_json::Value> {
let (req, reply) = crate::ControlRequest::new(method, params);
tx.send(req).unwrap();
reply
}
/// The block with its boss and hole, driven over the control channel.
fn agent_harness() -> (Harness, std::sync::mpsc::Sender<crate::ControlRequest>) {
let mut h = block_boss_hole();
h.app.preferences.agent_off_thread = true;
let (tx, rx) = std::sync::mpsc::channel();
h.app.control_rx = Some(rx);
(h, tx)
}
/// Frames until `reply` lands (a few seconds at most).
fn reply_to(h: &mut Harness, reply: &std::sync::mpsc::Receiver<serde_json::Value>) -> serde_json::Value {
for _ in 0..500 {
if let Ok(v) = reply.try_recv() {
return v;
}
h.frames(1);
std::thread::sleep(Duration::from_millis(10));
}
panic!("no reply");
}
fn second_hole() -> serde_json::Value {
json!({"command": "solid.cylinder", "params": {"base": [50, 10, -1], "axis": [0, 0, 1], "radius": 3, "height": 20, "operation": "cut"}})
}
/// #1989: an agent's design change computes off the window thread. The window keeps answering
/// (`ui.*`, inspection) while it computes and shows which command it is; the agent's next
/// design change waits its turn; each lands as its own undo step with its usual reply.
#[test]
fn an_agent_design_change_computes_off_the_window_thread() {
let (mut h, tx) = agent_harness();
let features = h.app.session.doc.features.len();
let undo = h.app.session.undo.len();
let hole = ask(&tx, "engine.execute", second_hole());
let view = ask(&tx, "ui.inspect", json!({}));
let inspect = ask(&tx, "document.inspect", json!({}));
let boss = ask(
&tx,
"engine.execute",
json!({"command": "solid.box", "params": {"corner": [40, 5, 10], "length": 5, "width": 5, "height": 5, "operation": "join"}}),
);
h.frames(1);
assert!(h.app.agent_computing().is_some_and(|(_, label)| !label.is_empty()), "the window says the agent's command computes");
assert!(view.try_recv().is_ok_and(|v| v["ok"] == true), "ui.* answered while it computes");
let seen = inspect.try_recv().expect("inspection answered while it computes");
assert_eq!(seen["result"]["timeline"].as_array().map(Vec::len), Some(features), "the design as it was: {seen}");
assert!(boss.try_recv().is_err(), "the next design change waits its turn");
assert_eq!(h.app.session.doc.features.len(), features, "nothing applied yet");
let r = reply_to(&mut h, &hole);
assert_eq!(r["ok"], true, "{r}");
let r = reply_to(&mut h, &boss);
assert_eq!(r["ok"], true, "{r}");
assert_eq!(h.app.session.doc.features.len(), features + 2);
assert_eq!(h.app.session.undo.len(), undo + 2, "one undo step each");
assert!(h.app.agent_computing().is_none());
// In the order they were asked for: undo takes the boss, the hole stays.
h.app.run("edit.undo", json!({})).unwrap();
let holes = std::f64::consts::PI * (4.0 * 15.0 + 9.0 * 10.0);
let v = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
assert!((v - (12500.0 - holes)).abs() < 1.0, "{v}");
}
/// A person's edit while the agent's command computes goes first; the agent's command is
/// computed again for the design as it is and lands after it, never in between.
#[test]
fn a_persons_edit_meanwhile_goes_first_and_the_agents_lands_after() {
let (mut h, tx) = agent_harness();
let features = h.app.session.doc.features.len();
let hole = ask(&tx, "engine.execute", second_hole());
h.frames(1);
assert!(h.app.agent_computing().is_some());
h.app.run("solid.box", json!({"corner": [40, 5, 10], "length": 5, "width": 5, "height": 5, "operation": "join"})).unwrap();
let r = reply_to(&mut h, &hole);
assert_eq!(r["ok"], true, "{r}");
assert_eq!(h.app.session.doc.features.len(), features + 2, "both kept");
// Undo takes the agent's hole first: it came last.
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(h.app.session.doc.features.len(), features + 1);
let boss = 12500.0 + 125.0 - std::f64::consts::PI * 4.0 * 15.0;
let v = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
assert!((v - boss).abs() < 1.0, "the person's boss stays: {v}");
}
/// A design replaced while the agent's command computes (another tab, a new design) is not
/// where it lands: it is refused, saying so, and nothing is applied.
#[test]
fn an_agent_command_is_refused_when_its_design_was_replaced() {
let (mut h, tx) = agent_harness();
let hole = ask(&tx, "engine.execute", second_hole());
h.frames(1);
assert!(h.app.agent_computing().is_some());
h.app.run("file.new", json!({})).unwrap();
let r = reply_to(&mut h, &hole);
assert_eq!(r["ok"], false, "{r}");
assert!(r["error"].as_str().is_some_and(|e| e.contains("replaced") && e.contains("nothing was applied")), "{r}");
assert!(h.app.session.doc.features.is_empty(), "nothing went into the new design");
}
/// Stop answers the agent at once, applies nothing, and lets the requests behind it go on.
#[test]
fn stopping_an_agent_command_applies_nothing_and_goes_on() {
let (mut h, tx) = agent_harness();
let features = h.app.session.doc.features.len();
let hole = ask(&tx, "engine.execute", second_hole());
let boss = ask(
&tx,
"engine.execute",
json!({"command": "solid.box", "params": {"corner": [40, 5, 10], "length": 5, "width": 5, "height": 5, "operation": "join"}}),
);
h.frames(1);
assert!(h.app.agent_computing().is_some());
h.app.stop_agent_command();
let r = hole.try_recv().expect("answered at once");
assert!(r["ok"] == false && r["stopped"] == true, "{r}");
let r = reply_to(&mut h, &boss);
assert_eq!(r["ok"], true, "{r}");
assert_eq!(h.app.session.doc.features.len(), features + 1, "only the boss");
}
/// A batch computes off the window thread too, with the reply a batch run here gives.
#[test]
fn an_agent_batch_computes_off_the_window_thread() {
let (mut h, tx) = agent_harness();
let features = h.app.session.doc.features.len();
let steps = json!({"commands": [second_hole(), {"command": "solid.box", "params": {"corner": [40, 5, 10], "length": 5, "width": 5, "height": 5, "operation": "join"}}]});
let batch = ask(&tx, "engine.batch", steps);
h.frames(1);
assert!(h.app.agent_computing().is_some(), "computing");
assert_eq!(h.app.session.doc.features.len(), features);
let r = reply_to(&mut h, &batch);
assert_eq!((&r["ok"], &r["result"]["completed"], &r["result"]["undone"]), (&json!(true), &json!(2), &json!(0)), "{r}");
assert_eq!(h.app.session.doc.features.len(), features + 2);
}
/// An export changes nothing in the design: it runs on a copy and answers from there, the file
/// written; a design change asked for meanwhile does not wait for it.
#[test]
fn an_agent_export_runs_on_a_copy() {
let (mut h, tx) = agent_harness();
let dir = std::env::temp_dir().join(format!("sc-agent-export-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("part.stl").to_string_lossy().to_string();
let export = ask(&tx, "engine.execute", json!({"command": "file.export", "params": {"path": path}}));
let r = reply_to(&mut h, &export);
assert_eq!(r["ok"], true, "{r}");
assert!(std::fs::metadata(&path).is_ok_and(|m| m.len() > 0), "written");
assert!(h.app.session.log.iter().any(|l| l.contains("Export")), "echoed as when it runs here: {:?}", h.app.session.log);
let _ = std::fs::remove_dir_all(&dir);
}
/// With the preference off (Preferences > AI, the default) an agent's design change runs on the
/// window thread, as before: answered in the frame it arrives.
#[test]
fn with_the_preference_off_an_agent_command_runs_at_once() {
let (mut h, tx) = agent_harness();
h.app.preferences.agent_off_thread = false;
let features = h.app.session.doc.features.len();
let hole = ask(&tx, "engine.execute", second_hole());
h.frames(1);
assert!(h.app.agent_computing().is_none());
assert!(hole.try_recv().is_ok_and(|r| r["ok"] == true), "answered in the same frame");
assert_eq!(h.app.session.doc.features.len(), features + 1);
}
/// #1989: with the agent cursor shown, the pointer acts out the agent's design change while it
/// computes off the window thread. Meanwhile the window answers `ui.*` and inspection (it used to
/// answer nothing at all until the command had run: a client polling the window saw it frozen),
/// and the next design change waits its turn.
#[test]
fn the_window_answers_while_the_agent_cursor_acts_out_a_design_change() {
let (mut h, tx) = agent_harness();
h.app.ui.agent_cursor.show = true;
h.frames(2);
let features = h.app.session.doc.features.len();
let hole = ask(&tx, "engine.execute", second_hole());
h.frames(1);
assert!(h.app.agent.busy(), "the pointer acts it out");
let view = ask(&tx, "ui.inspect", json!({}));
let inspect = ask(&tx, "document.inspect", json!({}));
let boss = ask(
&tx,
"engine.execute",
json!({"command": "solid.box", "params": {"corner": [40, 5, 10], "length": 5, "width": 5, "height": 5, "operation": "join"}}),
);
h.frames(1);
assert!(h.app.agent.busy());
assert!(view.try_recv().is_ok_and(|v| v["ok"] == true), "ui.* answered while the pointer acts out the command");
assert!(inspect.try_recv().is_ok_and(|v| v["ok"] == true), "inspection answered too");
assert!(boss.try_recv().is_err(), "the next design change waits its turn");
assert_eq!(h.app.session.doc.features.len(), features, "nothing applied yet");
let r = reply_to(&mut h, &hole);
assert_eq!(r["ok"], true, "{r}");
let r = reply_to(&mut h, &boss);
assert_eq!(r["ok"], true, "{r}");
assert_eq!(h.app.session.doc.features.len(), features + 2, "both, in order");
}
/// #1989: the run on the window thread reuses what was computed ahead, even when the evaluation
/// cache dropped it meanwhile (a design with large bodies keeps only a few states there): it
/// computes nothing again, so the window waits only for the bookkeeping. A parameter that drives
/// the whole timeline, changed by the agent with the cursor off and with it shown.
#[test]
fn the_window_thread_run_reuses_what_was_computed_ahead() {
for cursor in [false, true] {
let mut h = Harness::new();
h.app.home.open = false;
h.app.run("parameters.add", json!({"name": "len", "expression": "60 mm"})).unwrap();
for (id, p) in [
("solid.box", json!({"length": "len", "width": 20, "height": 10})),
("solid.box", json!({"corner": ["len / 2", 5, 10], "length": 10, "width": 10, "height": 5, "operation": "join"})),
("solid.cylinder", json!({"base": ["len / 2 + 5", 10, -1], "axis": [0, 0, 1], "radius": 2, "height": 20, "operation": "cut"})),
] {
h.app.run(id, p).unwrap();
}
h.app.apply_off_thread = Some(Duration::ZERO);
h.app.preferences.agent_off_thread = true;
h.app.ui.agent_cursor.show = cursor;
let (tx, rx) = std::sync::mpsc::channel();
h.app.control_rx = Some(rx);
h.frames(2);
let recomputed = h.app.session.model.recomputed;
let change = ask(&tx, "engine.execute", json!({"command": "parameters.change", "params": {"name": "len", "expression": "70 mm"}}));
let mut reply = None;
for _ in 0..500 {
// The cache drops everything the evaluation ahead puts there.
for _ in 0..2 {
*h.app.session.model.cache.lock().unwrap() = Default::default();
std::thread::sleep(Duration::from_millis(5));
}
h.frames(1);
if let Ok(v) = change.try_recv() {
reply = Some(v);
break;
}
}
let r = reply.expect("answered");
assert_eq!(r["ok"], true, "{r}");
assert_eq!(h.app.session.model.recomputed, recomputed, "cursor {cursor}: nothing computed again on the window thread");
let v = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();
let want = 70.0 * 200.0 + 500.0 - std::f64::consts::PI * 4.0 * 15.0;
assert!((v - want).abs() < 1.0, "the design as changed: {v}");
}
}
fn feature_ids(h: &Harness) -> Vec<u64> {
h.app.session.doc.features.iter().map(|f| f.id).collect()
}
+45 -28
View File
@@ -23,6 +23,7 @@ mod colour_vision_tests;
pub mod command_help;
pub mod context_menu;
pub mod control;
pub mod control_job;
pub mod crash_ui;
pub mod deferred;
pub mod delete;
@@ -466,8 +467,13 @@ pub struct SolveApp {
/// The modifiers of the synthetic press in progress (a Ctrl-drag keeps Ctrl while it moves).
pub synthetic_mods: egui::Modifiers,
control_rx: Option<Receiver<ControlRequest>>,
/// Control requests that change the design, held while a file loads.
/// Control requests that change the design, held while a file loads or an agent's design
/// change computes.
control_held: std::collections::VecDeque<ControlRequest>,
/// An agent's design change computing off the window thread ([`control_job`]).
control_job: Option<control_job::ControlJob>,
/// Agent exports computing on copies of the design.
control_answering: Vec<control_job::ControlJob>,
/// The agent cursor acting out control requests.
pub agent: agent_cursor::AgentCursor,
/// The agent chat panel (docs/design/in-app-agent-chat.md).
@@ -580,6 +586,8 @@ impl SolveApp {
control_rx: None,
agent_chat: Default::default(),
control_held: Default::default(),
control_job: None,
control_answering: Vec::new(),
agent: Default::default(),
pending_shots: Vec::new(),
queued_shots: Vec::new(),
@@ -1426,6 +1434,7 @@ impl SolveApp {
self.set_up_axis(self.ui.up_axis);
}
self.step_view_animation(ctx);
self.poll_control_jobs(ctx);
self.drain_control(ctx);
self.follow_view_request(true);
agent_cursor::step(self, ctx);
@@ -1673,15 +1682,15 @@ impl SolveApp {
return;
}
let rx = self.control_rx.take();
// While the agent cursor acts out a request, later ones wait their turn.
for _ in 0..PER_FRAME {
if self.agent.busy() {
break;
}
// Held requests go first, in order, once the file is in.
// A file loading, an agent's design change computing, or the agent cursor acting one
// out: commands that change the design wait their turn (the window, inspection and
// screenshots still answer, #1989).
let waits = self.file_load.busy() || self.file_picker.is_some() || self.control_job.is_some() || self.agent.busy();
// A screenshot waiting for an opened design to be meshed holds what came after it.
let shot_waits = open_meshing::active(self) && self.control_held.front().is_some_and(|r| r.method == "ui.screenshot");
let held = if self.file_load.busy() || self.file_picker.is_some() || shot_waits { None } else { self.control_held.pop_front() };
// Held requests go first, in order, once nothing makes them wait.
let held = if waits || shot_waits { None } else { self.control_held.pop_front() };
let Some(req) = held.or_else(|| rx.as_ref().and_then(|rx| rx.try_recv().ok())) else { break };
if shot_waits {
if self.control_held.len() < MAX_HELD {
@@ -1691,10 +1700,7 @@ impl SolveApp {
}
continue;
}
// A file is loading: commands that change the design wait for it (the window,
// inspection and screenshots still answer).
if ((self.file_load.busy() || self.file_picker.is_some())
&& matches!(req.method.as_str(), "engine.execute" | "command" | "engine.script" | "engine.batch"))
if (waits && control_job::changes_the_design(&req.method))
|| (self.file_picker_busy() && matches!(req.method.as_str(), "ui.file" | "ui.home"))
// A screenshot shows the whole design: it waits until an opened one is meshed.
|| (open_meshing::active(self) && req.method == "ui.screenshot")
@@ -1717,27 +1723,38 @@ impl SolveApp {
ctx.request_repaint();
continue;
}
match control::handle(self, ctx, &req) {
control::Outcome::Done(v) => {
let _ = reply.send(v);
}
// A window that is minimised or covered (another macOS Space) presents no frame:
// say so at once rather than after the deadline (#1677).
control::Outcome::Screenshot { .. } if window_hidden(ctx) => {
let _ = reply.send(json!({"ok": false, "hidden": true, "error": "no frame was presented (window hidden?); use ui.render"}));
}
control::Outcome::Screenshot { path } => {
self.shot_token += 1;
let token = self.shot_token;
self.queued_shots.push((token, now_ms() + 150.0, 0));
self.pending_shots.push((token, path, reply, now_ms() + 8000.0));
}
}
ctx.request_repaint();
// A slow design change or export: computed off the window thread (#1989).
let Some(req) = self.offload_control(ctx, req) else {
ctx.request_repaint();
continue;
};
self.run_control(ctx, req);
}
self.control_rx = rx;
}
/// Run a control request here, now, and reply (or queue the screenshot it asks for).
pub(crate) fn run_control(&mut self, ctx: &egui::Context, req: ControlRequest) {
let reply = req.reply.clone();
match control::handle(self, ctx, &req) {
control::Outcome::Done(v) => {
let _ = reply.send(v);
}
// A window that is minimised or covered (another macOS Space) presents no frame:
// say so at once rather than after the deadline (#1677).
control::Outcome::Screenshot { .. } if window_hidden(ctx) => {
let _ = reply.send(json!({"ok": false, "hidden": true, "error": "no frame was presented (window hidden?); use ui.render"}));
}
control::Outcome::Screenshot { path } => {
self.shot_token += 1;
let token = self.shot_token;
self.queued_shots.push((token, now_ms() + 150.0, 0));
self.pending_shots.push((token, path, reply, now_ms() + 8000.0));
}
}
ctx.request_repaint();
}
fn issue_screenshots(&mut self, ctx: &egui::Context) {
let now = now_ms();
self.queued_shots.retain_mut(|(token, at, frames)| {
+4
View File
@@ -463,6 +463,10 @@ preference_settings! {
ai_features: bool = true, PAGE_AI;
/// The Assistant button in the application bar (the shortcut and View menu entry stay).
ai_toolbar_button: bool = true, PAGE_AI;
/// An agent's slow commands over the control channel (MCP) compute off the window thread,
/// so the window stays live while they run (#1989, [`crate::control_job`]). Off: they run on
/// the window thread, and the window waits for each, as before (the default).
agent_off_thread: bool = false, PAGE_AI;
/// Agents the user added (the installed ones are found by themselves). API keys are never
/// here: they live in the system keychain.
agents: Vec<crate::agent_chat::agents::AgentConfig> = Vec::new();
+33
View File
@@ -2986,6 +2986,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
crate::select_other::show(app, ui.ctx());
axis_view(app, ui, rect);
nav_bar(app, ui, rect);
agent_chip(app, ui, rect);
transient_messages(app, ui, rect);
}
@@ -3009,6 +3010,38 @@ fn paint_box_selection(painter: &egui::Painter, bx: BoxSel, sketch: bool) {
}
}
/// An agent's command computing off the window thread (#1989): which one, in the agent cursor's
/// colour, and a button that stops waiting for it.
fn agent_chip(app: &mut SolveApp, ui: &egui::Ui, rect: Rect) {
let t = Tokens::get();
let painter = ui.painter().clone();
if let Some((since, label)) = app.agent_computing().map(|(since, label)| (since, label.to_string())) {
let seconds = ((crate::now_ms() - since) / 1000.0).floor().max(0.0);
let computing = crate::i18n::format("dialog.computing", &[("seconds", &format!("{seconds:.0}"))]);
let above = if app.computing_since().is_some() { 106.0 } else { 76.0 };
let pos = pos2(rect.left() + 12.0, rect.bottom() - above);
let galley = painter.layout_no_wrap(format!("{label} · {computing}"), FontId::proportional(t.font_label), t.text);
let stop = painter.layout_no_wrap(crate::i18n::tr("ui.agent_chat_stop").to_string(), FontId::proportional(t.font_label), t.text);
let r = Rect::from_min_size(pos, vec2(galley.size().x + stop.size().x + 54.0, galley.size().y.max(stop.size().y) + 8.0));
painter.rect_filled(r, 4.0, t.overlay);
painter.rect_stroke(r, 4.0, Stroke::new(1.0, crate::icons::pointer::agent()), egui::StrokeKind::Inside);
egui::Spinner::new()
.color(crate::icons::pointer::agent())
.size(t.space_12)
.paint_at(ui, Rect::from_center_size(pos2(r.left() + 13.0, r.center().y), vec2(12.0, 12.0)));
painter.galley(pos + vec2(26.0, 4.0), galley.clone(), t.text);
let button = Rect::from_min_size(pos2(pos.x + galley.size().x + 34.0, r.top() + 2.0), vec2(stop.size().x + 12.0, r.height() - 4.0));
let clicked = ui.interact(button, egui::Id::new("sc_agent_stop"), Sense::click());
painter.rect_filled(button, 3.0, if clicked.hovered() { t.hover } else { t.overlay });
painter.galley(button.min + vec2(6.0, 2.0), stop, t.text);
crate::scenario::publish_handle("agent:stop", button.center());
if clicked.clicked() {
app.stop_agent_command();
}
ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));
}
}
/// A single visual pattern for ongoing work and the existing six-second status.
fn transient_messages(app: &mut SolveApp, ui: &egui::Ui, viewport: Rect) {
if app.status.is_none() && app.computing_since().is_none() {
+32
View File
@@ -99,6 +99,38 @@ MCP server sends its folders this way on every request ([mcp.md](mcp.md)). Witho
Commands never open dialogs when run this way. `solidcraft-cli commands` prints the same registry.
### Slow commands and the window (#1989)
With the preference **Preferences > AI > Keep the window responsive while agents run commands**
on (`ui.prefs {"agent_off_thread": true}`; off by default), a design change in the desktop app
that takes longer than about 150 ms (an `engine.execute` of a
modelling command, an `engine.batch` of them) computes off the window thread, so the window keeps
drawing and answering while it runs:
- The command is evaluated ahead on a copy of the design, which also makes the display meshes of
the bodies it ends with. Then it runs for real on the window thread, reusing every feature the
evaluation computed (kept for it, whatever the bounded evaluation cache dropped meanwhile), so
the window waits only for the bookkeeping. Its reply, undo step, autosave and crash journal are
the same as before. With the agent cursor shown, the evaluation runs while the pointer glides
to the button, and the pointer waits there until it is done.
- Meanwhile `ui.*` requests, `document.inspect` and `engine.commands` are answered at once
(inspection shows the design as it was), also while the agent cursor acts a command out. Later
design changes, from any connection, wait their turn and run in the order they arrived.
- A person's edit made meanwhile goes first. The agent's command is then computed again for the
design as it is and lands after that edit, never in the middle of it. If the design was replaced
(another tab made active, a new file opened), the request fails with `… the design was
replaced … nothing was applied`.
- A chip in the view names the command, with **Stop**. Stop answers
`{"ok": false, "stopped": true, "error": "stopped: …; nothing was applied"}` and the requests
waiting behind it go on. The computation finishes unseen in the background.
- `file.export` and `file.save_mesh` change nothing in the design. They run on a copy of the
design as it was when they were asked for, and nothing waits behind them.
- Batches with `timings` or `profile` still run on the window thread, so the times they report
measure the real work.
Timeouts and `control.pending` work as described above. A slow command is still answered when it
is done, from a later frame. With the preference off, commands run on the window thread, and the
window waits for each one.
Product images use `render.preflight/start/status/cancel/export` through `engine.execute`.
Keep the returned session-scoped job ID for subsequent calls; status does not block or
render. See [render jobs](render-jobs.md) for capture, cancellation and export semantics.