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:
@@ -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",
|
||||
|
||||
@@ -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": "エージェントを追加",
|
||||
|
||||
@@ -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
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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" {
|
||||
|
||||
@@ -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, ¶ms) => 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, ¶ms).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, ¶ms) {
|
||||
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();
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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)| {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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.
|
||||
|
||||
Reference in New Issue
Block a user