Assistant: a request timeout per endpoint for slow models (#5009) (#5010)

* claim: #5009

* Assistant: a request timeout per endpoint for slow models (#5009)

An OpenAI-compatible endpoint now stores how long one model request may
take (request_timeout_s, 300 s by default, clamped to 30 s ..= 1 h). It
is set in the Add agent dialog and in the endpoint's entry under Agents
(a running conversation uses a change from its next request), through
ui.agent_chat add_agent, and reported in the chat's state. A request
that runs out of time says the limit and where to raise it instead of
"timeout: global". The desktop HTTP cap goes from 900 s to an hour.

The tool-call timeout stays 330 s: it covers SolidCraft's own tool work
and the user's Allow, never the model.

* Assistant settings: line up an endpoint's Request timeout with Permissions

The label column of an agent's entry is wide enough for "Request timeout",
so the label isn't cut and both rows share one column.
This commit is contained in:
raykholo
2026-10-24 22:24:42 +00:00
committed by GitHub
parent 88f079bd8c
commit 4cd1a51f48
12 changed files with 206 additions and 14 deletions
+1 -1
View File
@@ -369,7 +369,7 @@ fn agent_http(r: &solidcraft_ui_egui::agent_chat::backend::HttpRequest) -> Resul
let agent: ureq::Agent = ureq::Agent::config_builder()
.tls_config(tls)
.http_status_as_error(false)
.timeout_global(Some(Duration::from_secs(r.timeout_s.clamp(1, 900))))
.timeout_global(Some(Duration::from_secs(r.timeout_s.clamp(1, 3600))))
.timeout_connect(Some(Duration::from_secs(10)))
.user_agent("SolidCraft")
.max_redirects(0)
+3
View File
@@ -2428,6 +2428,9 @@
"ui.ai_protocol": "Protocol",
"ui.ai_remove": "Remove",
"ui.ai_request_limit": "stopped after 24 requests for one message; send another message to go on",
"ui.ai_request_timed_out": "The model took longer than {seconds} s. You can raise the request timeout for this endpoint in Preferences › Assistant.",
"ui.ai_request_timeout": "Request timeout",
"ui.ai_request_timeout_hint": "How long one model request to this endpoint may take, from 30 s to an hour. Raise it for a slow local model.",
"ui.ai_reset": "Reset",
"ui.ai_settings": "AI settings…",
"ui.ai_show_features": "Show AI features",
+3
View File
@@ -2428,6 +2428,9 @@
"ui.ai_protocol": "プロトコル",
"ui.ai_remove": "削除",
"ui.ai_request_limit": "1メッセージあたり24リクエストで停止しました。続けるには、もう一度メッセージを送ってください",
"ui.ai_request_timed_out": "モデルの応答に {seconds} 秒以上かかりました。このエンドポイントのリクエストのタイムアウトは、環境設定 › アシスタントで長くできます。",
"ui.ai_request_timeout": "リクエストのタイムアウト",
"ui.ai_request_timeout_hint": "このエンドポイントへのモデルリクエスト1回にかけられる時間です(30秒〜1時間)。遅いローカルモデルでは長くしてください。",
"ui.ai_reset": "リセット",
"ui.ai_settings": "AI 設定…",
"ui.ai_show_features": "AI 機能を表示",
+3
View File
@@ -2428,6 +2428,9 @@
"ui.ai_protocol": "协议",
"ui.ai_remove": "移除",
"ui.ai_request_limit": "每条消息 24 次请求后已停止;再发送一条消息即可继续",
"ui.ai_request_timed_out": "模型用时超过 {seconds} 秒。可在“首选项 › 助手”中调高此端点的请求超时。",
"ui.ai_request_timeout": "请求超时",
"ui.ai_request_timeout_hint": "对此端点的一次模型请求最多可用的时间,30 秒到 1 小时。本地模型较慢时请调高。",
"ui.ai_reset": "重置",
"ui.ai_settings": "AI 设置…",
"ui.ai_show_features": "显示 AI 功能",
+59 -1
View File
@@ -95,7 +95,7 @@ impl Protocol {
}
/// An agent the user added.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct AgentConfig {
pub id: String,
@@ -108,6 +108,41 @@ pub struct AgentConfig {
pub model: String,
/// API: a key is stored for it in the system keychain.
pub key: bool,
/// API: how long one model request may take, in seconds (clamped to
/// [`MIN_REQUEST_TIMEOUT_S`]..=[`MAX_REQUEST_TIMEOUT_S`] where it is used).
pub request_timeout_s: u64,
}
impl Default for AgentConfig {
fn default() -> AgentConfig {
AgentConfig {
id: String::new(),
name: String::new(),
kind: Kind::default(),
command: String::new(),
base_url: String::new(),
model: String::new(),
key: false,
request_timeout_s: DEFAULT_REQUEST_TIMEOUT_S,
}
}
}
/// How long one model request to an endpoint may take by default, in seconds.
pub const DEFAULT_REQUEST_TIMEOUT_S: u64 = 300;
/// The shortest request timeout an endpoint can have.
pub const MIN_REQUEST_TIMEOUT_S: u64 = 30;
/// The longest request timeout an endpoint can have (an hour).
pub const MAX_REQUEST_TIMEOUT_S: u64 = 3600;
/// A request timeout in range: seconds from a preferences file, the dialog or the control
/// channel, rounded and clamped; anything not a finite number is the default.
pub fn request_timeout_s(secs: f64) -> u64 {
if !secs.is_finite() {
return DEFAULT_REQUEST_TIMEOUT_S;
}
// Clamped first, so the cast is exact.
secs.round().clamp(MIN_REQUEST_TIMEOUT_S as f64, MAX_REQUEST_TIMEOUT_S as f64) as u64
}
/// An agent as the picker and the switcher show it.
@@ -126,6 +161,8 @@ pub struct Entry {
pub base_url: String,
pub model: String,
pub key: bool,
/// API: seconds one model request may take (in range).
pub request_timeout_s: u64,
}
impl Entry {
@@ -141,6 +178,7 @@ impl Entry {
base_url: c.base_url.clone(),
model: c.model.clone(),
key: c.key,
request_timeout_s: c.request_timeout_s.clamp(MIN_REQUEST_TIMEOUT_S, MAX_REQUEST_TIMEOUT_S),
}
}
/// A short line under the name: the version, the model, or the command.
@@ -171,6 +209,7 @@ pub fn entries(app: &crate::SolveApp) -> Vec<Entry> {
base_url: String::new(),
model: String::new(),
key: false,
request_timeout_s: DEFAULT_REQUEST_TIMEOUT_S,
}));
}
out.extend(app.preferences.agents.iter().map(Entry::from_config));
@@ -309,4 +348,23 @@ mod tests {
assert!(presets(Protocol::OpenAi).iter().all(|p| !p.name.is_empty() && p.base_url.starts_with("http")));
assert!(presets(Protocol::Anthropic).iter().any(|p| p.base_url == "https://api.anthropic.com/v1"));
}
#[test]
fn request_timeouts_default_to_300_s_and_stay_between_30_s_and_an_hour() {
assert_eq!(AgentConfig::default().request_timeout_s, 300);
assert_eq!(request_timeout_s(600.4), 600);
assert_eq!(request_timeout_s(1.0), 30);
assert_eq!(request_timeout_s(-5.0), 30);
assert_eq!(request_timeout_s(1e300), 3600);
assert_eq!(request_timeout_s(f64::NAN), 300);
assert_eq!(request_timeout_s(f64::INFINITY), 300);
// An older preferences file has no timeout: the default; a hand-edited one is clamped where used.
let old: AgentConfig = serde_json::from_str(r#"{"id":"api-1","kind":"api","base_url":"http://localhost:11434/v1","model":"m"}"#).unwrap();
assert_eq!(old.request_timeout_s, 300);
let wild: AgentConfig = serde_json::from_str(r#"{"id":"api-2","kind":"api","request_timeout_s":99999}"#).unwrap();
assert_eq!(Entry::from_config(&wild).request_timeout_s, 3600);
let saved = AgentConfig { id: "api-3".into(), kind: Kind::Api, request_timeout_s: 1200, ..Default::default() };
let back: AgentConfig = serde_json::from_value(serde_json::to_value(&saved).unwrap()).unwrap();
assert_eq!(back, saved);
}
}
+47 -6
View File
@@ -26,9 +26,10 @@ pub const MAX_REQUESTS_PER_TURN: usize = 24;
const MAX_TOOL_TEXT: usize = 20_000;
/// Messages kept in the conversation (the system note stays).
const MAX_HISTORY: usize = 240;
/// How long one model request may take.
const REQUEST_TIMEOUT_S: u64 = 300;
/// How long one tool call may take (it may wait for the user's Allow).
/// How long one tool call may take (it may wait for the user's Allow, declined after four
/// minutes). It does not depend on the endpoint's request timeout: a tool call is SolidCraft's own
/// work and the user's answer, never a wait for the model, so a longer request timeout does not
/// need a longer tool timeout.
const TOOL_TIMEOUT: Duration = Duration::from_secs(330);
/// How often a waiting request or tool call looks at the cancel flag.
const CANCEL_POLL: Duration = Duration::from_millis(40);
@@ -51,12 +52,15 @@ pub struct ApiConfig {
pub model: String,
pub key: Option<String>,
pub http: HttpFn,
/// How long one model request may take, in seconds (the endpoint's setting).
pub request_timeout_s: u64,
}
enum Cmd {
Prompt(Vec<PromptPart>),
NewChat,
SetModel(String),
SetRequestTimeout(u64),
}
pub struct ApiBackend {
@@ -122,6 +126,11 @@ impl ChatBackend for ApiBackend {
let _ = c.send(Cmd::SetModel(model.to_string()));
}
}
fn set_request_timeout(&mut self, secs: u64) {
if let Some(c) = &self.cmds {
let _ = c.send(Cmd::SetRequestTimeout(secs));
}
}
fn new_session(&mut self) {
// A running turn is cancelled; the worker resets the history once it has ended.
self.cancel.store(true, Ordering::Relaxed);
@@ -191,6 +200,7 @@ impl Worker {
match cmd {
Cmd::Prompt(parts) => self.turn(parts),
Cmd::SetModel(m) => self.cfg.model = m,
Cmd::SetRequestTimeout(secs) => self.cfg.request_timeout_s = secs,
Cmd::NewChat => {
self.history.clear();
self.cancel.store(false, Ordering::Relaxed);
@@ -431,21 +441,26 @@ impl Worker {
Protocol::Anthropic => headers.push(("x-api-key".into(), k.clone())),
}
}
let req = HttpRequest { method: "POST", url, headers, body: Some(body.to_string().into_bytes()), timeout_s: REQUEST_TIMEOUT_S };
let req = HttpRequest { method: "POST", url, headers, body: Some(body.to_string().into_bytes()), timeout_s: self.limit_s() };
// The request runs on a thread of its own so that Stop does not wait for the model: a
// cancelled one is abandoned (the host's own timeout ends it) and its answer dropped.
let (tx, rx) = channel();
let http = self.cfg.http.clone();
let started = std::time::Instant::now();
std::thread::spawn(move || {
let _ = tx.send(http(&req));
});
// The host ends the request at the limit; a few seconds more is the backstop for one
// that does not.
let backstop = Duration::from_secs(self.limit_s().saturating_add(5));
let (status, bytes) = loop {
if self.cancel.load(Ordering::Relaxed) {
return Err("cancelled by the user".into());
}
match rx.recv_timeout(CANCEL_POLL) {
Ok(r) => break r?,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {}
Ok(r) => break r.map_err(|e| request_error(e, started.elapsed(), self.limit_s()))?,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) if started.elapsed() < backstop => {}
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => return Err(timed_out(self.limit_s())),
Err(_) => return Err("the request ended without an answer".into()),
}
};
@@ -453,6 +468,24 @@ impl Worker {
}
}
impl Worker {
/// The endpoint's request timeout, in range.
fn limit_s(&self) -> u64 {
self.cfg.request_timeout_s.clamp(super::agents::MIN_REQUEST_TIMEOUT_S, super::agents::MAX_REQUEST_TIMEOUT_S)
}
}
/// What the chat says when a request ran out of time: the limit, and where to raise it.
pub fn timed_out(limit_s: u64) -> String {
crate::i18n::format("ui.ai_request_timed_out", &[("seconds", &limit_s.to_string())])
}
/// A failed request as people read it: one that ran into the endpoint's request timeout (the
/// host says so, or it failed at the limit) says the limit and where to raise it.
pub fn request_error(error: String, elapsed: Duration, limit_s: u64) -> String {
if error.starts_with("timeout: global") || elapsed >= Duration::from_secs(limit_s) { timed_out(limit_s) } else { error }
}
/// An endpoint's refusal as people read it.
pub fn http_error(status: u16, body: &Value) -> String {
let detail =
@@ -898,6 +931,7 @@ mod tests {
model: "m".into(),
key: None,
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
let mut b = ApiBackend::start(cfg, ctx).unwrap();
@@ -951,6 +985,7 @@ mod tests {
model: "m".into(),
key: None,
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
let mut b = ApiBackend::start(cfg, ctx).unwrap();
@@ -1005,6 +1040,7 @@ mod tests {
model: "m".into(),
key: None,
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
let mut b = ApiBackend::start(cfg, ctx).unwrap();
@@ -1050,6 +1086,7 @@ mod tests {
model: "local".into(),
key: None,
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
let mut b = ApiBackend::start(cfg, ctx).unwrap();
@@ -1106,6 +1143,7 @@ mod tests {
model: "m".into(),
key: None,
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
let mut b = ApiBackend::start(cfg, ctx).unwrap();
@@ -1139,6 +1177,7 @@ mod tests {
model: "m".into(),
key: Some("k".into()),
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
assert!(ApiBackend::start(cfg, ctx).is_err());
@@ -1162,6 +1201,7 @@ mod tests {
model: "m".into(),
key: Some("sk-secret".into()),
http,
request_timeout_s: 300,
};
let (events, _rx) = channel();
let w = Worker {
@@ -1288,6 +1328,7 @@ mod tests {
model: "m".into(),
key: Some("sk-secret".into()),
http,
request_timeout_s: 300,
};
let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };
let mut b = ApiBackend::start(cfg, ctx).unwrap();
+2
View File
@@ -92,6 +92,8 @@ pub trait ChatBackend {
fn set_model(&mut self, _model: &str) {}
/// Switch to one of the modes it reported in [`Event::Modes`].
fn set_mode(&mut self, _mode: &str) {}
/// An endpoint's new request timeout, in seconds, from the next request on.
fn set_request_timeout(&mut self, _secs: u64) {}
/// Its process, for status and tests.
fn pid(&self) -> Option<u32> {
None
+11 -3
View File
@@ -803,6 +803,7 @@ pub fn connect(app: &mut SolveApp, ctx: &egui::Context) {
model: entry.model.clone(),
key,
http,
request_timeout_s: entry.request_timeout_s,
},
start,
)
@@ -1621,9 +1622,16 @@ pub fn control(app: &mut SolveApp, ctx: &egui::Context, p: &Value) -> Result<Val
let Some(mode) = m.as_str().and_then(agents::Mode::parse) else { return Err("permissions must be ask, edits or all".into()) };
app.preferences.ai_permissions = mode;
}
// Add an agent (as the Add agent dialog does), for tests and screenshots: {id?, name, kind, command | base_url + model}.
// Add an agent (as the Add agent dialog does), for tests and screenshots:
// {id?, name, kind, command | base_url + model + request_timeout_s?}.
if let Some(a) = p.get("add_agent") {
let mut c: agents::AgentConfig = serde_json::from_value(a.clone()).map_err(|e| format!("add_agent: {e}"))?;
let mut a = a.clone();
// Seconds are rounded and clamped to 30 s ..= 1 h, not refused for being out of range.
if let Some(t) = a.as_object_mut().and_then(|o| o.get_mut("request_timeout_s")) {
let secs = t.as_f64().filter(|s| s.is_finite()).ok_or("add_agent: request_timeout_s must be a number of seconds")?;
*t = json!(agents::request_timeout_s(secs));
}
let mut c: agents::AgentConfig = serde_json::from_value(a).map_err(|e| format!("add_agent: {e}"))?;
if c.id.is_empty() {
c.id = agents::new_id(&app.preferences, if c.kind.is_api() { c.kind.id() } else { "custom" });
}
@@ -1799,7 +1807,7 @@ pub fn status(app: &SolveApp) -> Value {
"features": app.preferences.ai_features,
"toolbarButton": app.preferences.ai_toolbar_button,
"permissions": app.preferences.ai_permissions.id(),
"agents": agents::entries(app).iter().map(|e| json!({"id": e.id, "name": e.name, "kind": e.kind.id(), "found": e.found, "version": e.version, "login": e.login})).collect::<Vec<_>>(),
"agents": agents::entries(app).iter().map(|e| json!({"id": e.id, "name": e.name, "kind": e.kind.id(), "found": e.found, "version": e.version, "login": e.login, "request_timeout_s": e.kind.is_api().then_some(e.request_timeout_s)})).collect::<Vec<_>>(),
"currentAgent": agents::current(app).map(|e| e.id),
"models": c.models.iter().map(|m| json!({"id": m.id, "name": m.name, "description": m.description})).collect::<Vec<_>>(),
"model": c.model,
+40 -1
View File
@@ -27,6 +27,8 @@ pub struct AddState {
pub base_url: String,
pub model: String,
pub key: String,
/// Seconds one model request may take.
pub request_timeout_s: u64,
pub error: Option<String>,
test: Option<Test>,
}
@@ -60,6 +62,7 @@ pub fn open_add(app: &mut SolveApp) {
app.agent_chat.settings.add = Some(AddState {
base_url: preset.map(|p| p.base_url.to_string()).unwrap_or_default(),
name: preset.map(|p| p.name.to_string()).unwrap_or_default(),
request_timeout_s: agents::DEFAULT_REQUEST_TIMEOUT_S,
..Default::default()
});
}
@@ -108,6 +111,14 @@ fn start_test(app: &SolveApp, e: &agents::Entry, key: Option<String>) -> Test {
Test::Running(rx)
}
/// An endpoint's request timeout field: seconds, 30 s to an hour.
fn timeout_field(ui: &mut egui::Ui, secs: &mut u64, handle: &str) -> bool {
let r = ui_kit::number_field(ui, secs, agents::MIN_REQUEST_TIMEOUT_S..=agents::MAX_REQUEST_TIMEOUT_S, 5.0, " s")
.on_hover_text(tr("ui.ai_request_timeout_hint"));
crate::scenario::publish_target(handle, r.rect);
r.changed()
}
fn test_line(ui: &mut egui::Ui, test: &Option<&Test>) {
match test {
Some(Test::Running(_)) => {
@@ -277,6 +288,7 @@ fn agents_section(app: &mut SolveApp, ui: &mut egui::Ui) {
let default = if all.iter().any(|e| &e.id == d) { Some(d.clone()) } else { all.first().map(|e| e.id.clone()) };
let mut remove: Option<String> = None;
let mut test: Option<agents::Entry> = None;
let mut retimed: Option<(String, u64)> = None;
let t = crate::theme::Tokens::get();
ui_kit::settings_section(ui, "agents", tr("ui.ai_agents"), |ui| {
if app.agent_chat.detecting.is_some() {
@@ -329,7 +341,9 @@ fn agents_section(app: &mut SolveApp, ui: &mut egui::Ui) {
}
});
ui_kit::settings_short_note(ui, &entry.detail());
ui_kit::settings_form(ui, t.form_label_width + t.space_16, |ui| {
// Wide enough for an endpoint's "Request timeout" too, so both rows line up.
let label_w = (t.form_label_width + t.space_16).max(ui_kit::ContentWidth::label(ui, tr("ui.ai_request_timeout")) + t.space_16);
ui_kit::settings_form(ui, label_w, |ui| {
ui_kit::row(ui, tr("ui.ai_permissions"), |ui| {
let current = app.preferences.agent_permissions.get(&entry.id).copied();
let shown = current.map_or_else(|| tr("ui.ai_mode_global").to_owned(), |mode| mode.label().to_owned());
@@ -355,6 +369,19 @@ fn agents_section(app: &mut SolveApp, ui: &mut egui::Ui) {
}
});
});
if entry.kind == Kind::Api
&& let Some(c) = app.preferences.agents.iter_mut().find(|c| c.id == entry.id)
{
ui_kit::settings_form(ui, label_w, |ui| {
ui_kit::row(ui, tr("ui.ai_request_timeout"), |ui| {
let mut secs = entry.request_timeout_s;
if timeout_field(ui, &mut secs, &format!("prefs:ai_timeout:{}", entry.id)) {
c.request_timeout_s = secs;
retimed = Some((entry.id.clone(), secs));
}
});
});
}
if app.preferences.agent_permissions.get(&entry.id) == Some(&Mode::All) {
ui_kit::text(ui, tr("ai.prefs.override_all_warning"), ui_kit::Text::Report("agent_permissions_warning", true))
.on_hover_text(tr("ui.ai_mode_all_warning"));
@@ -379,6 +406,13 @@ fn agents_section(app: &mut SolveApp, ui: &mut egui::Ui) {
let started = start_test(app, &e, key);
app.agent_chat.settings.tests.insert(e.id.clone(), started);
}
// The running conversation uses a new timeout from its next request on.
if let Some((id, secs)) = retimed
&& app.agent_chat.running_id == id
&& let Some(b) = app.agent_chat.backend.as_mut()
{
b.set_request_timeout(secs);
}
if let Some(id) = remove {
app.preferences.agents.retain(|a| a.id != id);
app.preferences.agent_permissions.remove(&id);
@@ -513,6 +547,9 @@ pub fn dialog(app: &mut SolveApp, ctx: &egui::Context) {
ui_kit::row(ui, tr("ui.ai_model"), |ui| {
ui_kit::text_field(ui, &mut s.model, tr("ui.ai_model_hint"));
});
ui_kit::row(ui, tr("ui.ai_request_timeout"), |ui| {
timeout_field(ui, &mut s.request_timeout_s, "ai_add:request_timeout");
});
ui_kit::row(ui, tr("ui.ai_key"), |ui| {
ui.add_enabled_ui(has_keychain, |ui| {
let r = ui_kit::password_field(ui, egui::Id::new("sc_ai_add_key"), &mut s.key, tr("ui.ai_key_hint"));
@@ -550,6 +587,7 @@ pub fn dialog(app: &mut SolveApp, ctx: &egui::Context) {
base_url: url.clone().unwrap_or_default(),
model: s.model.trim().to_string(),
key: false,
request_timeout_s: s.request_timeout_s,
};
let key = Some(s.key.trim().to_string()).filter(|k| !k.is_empty());
let result = match url {
@@ -599,6 +637,7 @@ fn add_agent(app: &mut SolveApp) -> Result<(), String> {
c.kind = s.protocol.kind();
c.base_url = agents::normalize_url(&s.base_url)?;
c.model = s.model.trim().to_string();
c.request_timeout_s = s.request_timeout_s.clamp(agents::MIN_REQUEST_TIMEOUT_S, agents::MAX_REQUEST_TIMEOUT_S);
if c.model.is_empty() {
return Err(tr("ui.ai_need_model").to_string());
}
+31
View File
@@ -2020,3 +2020,34 @@ fn add_agent_opens_its_dialog_from_home() {
assert!(h.app.agent_chat.settings.add.is_some(), "Add agent opened its dialog");
assert!(handle_at("ai_add:add").is_some(), "the dialog is drawn over Home");
}
/// `ui.agent_chat` `add_agent` takes an endpoint's request timeout (rounded and clamped to 30 s
/// ..= 1 h, 300 s when left out) and the state reports it.
#[test]
fn add_agent_takes_a_request_timeout_and_the_state_reports_it() {
let ctx = egui::Context::default();
let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());
let timeout = |app: &mut SolveApp, id: &str| {
let state = control(app, &ctx, &json!({})).unwrap();
state["agents"].as_array().unwrap().iter().find(|a| a["id"] == id).map(|a| a["request_timeout_s"].clone())
};
let add = |app: &mut SolveApp, t: Value| {
let mut a = json!({"id": "slow", "name": "Slow", "kind": "api", "base_url": "http://localhost:11434/v1", "model": "m"});
if !t.is_null() {
a["request_timeout_s"] = t;
}
control(app, &ctx, &json!({"add_agent": a}))
};
add(&mut app, json!(1200)).unwrap();
assert_eq!(timeout(&mut app, "slow"), Some(json!(1200)));
assert_eq!(app.preferences.agents.iter().find(|a| a.id == "slow").unwrap().request_timeout_s, 1200);
add(&mut app, json!(99999.7)).unwrap();
assert_eq!(timeout(&mut app, "slow"), Some(json!(3600)));
add(&mut app, json!(-3)).unwrap();
assert_eq!(timeout(&mut app, "slow"), Some(json!(30)));
add(&mut app, Value::Null).unwrap();
assert_eq!(timeout(&mut app, "slow"), Some(json!(300)));
assert!(add(&mut app, json!("long")).is_err());
control(&mut app, &ctx, &json!({"add_agent": {"id": "acp", "name": "A", "command": "x --acp"}})).unwrap();
assert_eq!(timeout(&mut app, "acp"), Some(Value::Null), "only endpoints have a request timeout");
}
+5 -1
View File
@@ -208,7 +208,11 @@ Grok Build also supports `XAI_API_KEY` for users who choose API authentication.
OpenAI-compatible endpoint for its models; an Anthropic-compatible one gets a short message,
because not every such endpoint lists models (Qwen's has no model list). For these agents
SolidCraft runs the conversation itself, with the same tools, limits and questions as for a
coding agent, and at most 24 model requests per message.
coding agent, and at most 24 model requests per message. **Request timeout** is how long one model request may
take: 300 s by default, from 30 s to an hour. A slow local model (a large model on modest
hardware, or a long message with many tool results) may need more; raise it here or in the
endpoint's entry under **Agents**, where a change applies from the next request. A request that
runs out of time ends the message with the limit it hit and where to raise it.
## Signing in
+1 -1
View File
@@ -252,7 +252,7 @@ labels; `prefs:measure_axis_distances` identifies the checkbox.
| `engine.execute` → `browser.expand_all` | `path?`: occurrence ids; `component?`: id; omit both for the whole tree | Open every Browser row under that scope, including folders that start closed (Origin, Named Views, Features). Display only: not saved in the design, not an undo step. |
| `engine.execute` → `browser.collapse_all` | same | Close those rows. The design row stays open when the whole tree is collapsed. |
| `engine.execute` → `view.history_layout` | `width?`, `dock?`: `bottom`, `left`, `under_browser`, `collapsed?` | Resize/dock the history without opening a dialog or changing the design. Contents respond to measured width; browser-stacked history shares its width and splits height equally. One folded header gives the expanded card the rest; two folded headers stay at the top. |
| `ui.agent_chat` | `features?`, `toolbar_button?`, `permissions?` (`ask`, `edits`, `all`), `add_agent?` ({`name`, `kind`: `acp`, `api` or `anthropic` (`api` is OpenAI-compatible, `anthropic` Anthropic-compatible), `command` or `base_url` + `model`}; no keys), `add_dialog?` (`installed`, `custom`, `api`, `anthropic`, or `false` to close), `default_agent?`, `agent?` (the conversation's agent, by id), `mode?` (the agent's own mode), `model?` (one of its models), `open?`, `side?` (`left`, `right`), `minimized?`, `popped?` (in its own window), `width?`, `picker?`, `refresh?`, `connect?`, `stop?`, `attach?`: a file's path (a picture, a text file or a CAD file, for the next message; CAD files are imported at once), `remove_file?` (index of a file on the next message), `send?`: text (files alone make a message too), `attach_view?`, `attach_selection?`, `pick?` (true: open the context picker), `permission?`: an option id or `"cancel"` (the newest question of the agent's own), `approve?`: true, false or `"always"` (the oldest request held for Allow/Deny), `cancel?` (Stop: the queue stays), `send_now?` (stop the running step, then send the queued messages), `remove_pending?` (index), `new_chat?` (clear the chat, new session), `undo?` (the last message's changes) | the chat's state: `features`, `agents` (found and added), `currentAgent`, `state` (off, starting, ready, busy, auth, exited), `popped`, `window` (its place and size), `agent`, `modes`, `mode`, `models`, `model`, `authMethods`, `toolsPort`, `pid`, `waiting`, `turn`, `pending` (queued messages, with their `files`), `attachments` (the files on the next message, by name), `loading` (pictures still being read for it, by name), `stopped`, `detection` and the conversation (`items`). With `features` off only the settings apply. Desktop only; see [Agent chat](agent-chat.md) |
| `ui.agent_chat` | `features?`, `toolbar_button?`, `permissions?` (`ask`, `edits`, `all`), `add_agent?` ({`name`, `kind`: `acp`, `api` or `anthropic` (`api` is OpenAI-compatible, `anthropic` Anthropic-compatible), `command` or `base_url` + `model` + `request_timeout_s?` (seconds one model request may take, 300 by default, rounded and clamped to 30 to 3600)}; no keys), `add_dialog?` (`installed`, `custom`, `api`, `anthropic`, or `false` to close), `default_agent?`, `agent?` (the conversation's agent, by id), `mode?` (the agent's own mode), `model?` (one of its models), `open?`, `side?` (`left`, `right`), `minimized?`, `popped?` (in its own window), `width?`, `picker?`, `refresh?`, `connect?`, `stop?`, `attach?`: a file's path (a picture, a text file or a CAD file, for the next message; CAD files are imported at once), `remove_file?` (index of a file on the next message), `send?`: text (files alone make a message too), `attach_view?`, `attach_selection?`, `pick?` (true: open the context picker), `permission?`: an option id or `"cancel"` (the newest question of the agent's own), `approve?`: true, false or `"always"` (the oldest request held for Allow/Deny), `cancel?` (Stop: the queue stays), `send_now?` (stop the running step, then send the queued messages), `remove_pending?` (index), `new_chat?` (clear the chat, new session), `undo?` (the last message's changes) | the chat's state: `features`, `agents` (found and added), `currentAgent`, `state` (off, starting, ready, busy, auth, exited), `popped`, `window` (its place and size), `agent`, `modes`, `mode`, `models`, `model`, `authMethods`, `toolsPort`, `pid`, `waiting`, `turn`, `pending` (queued messages, with their `files`), `attachments` (the files on the next message, by name), `loading` (pictures still being read for it, by name), `stopped`, `detection` and the conversation (`items`). With `features` off only the settings apply. Desktop only; see [Agent chat](agent-chat.md) |
| `ui.resize` | `width`, `height` | |
| `app.quit` | `force?` (quit without asking about unsaved designs) | `quitting` (the window closes), `asking` (a "save changes?" prompt is open) |