SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Assistant: warn when an Ollama model has no tool support (#4846) (#4916)
raykholo4355d117efb2
diff --git a/assets/locales/pending/ollama-model-no-tools.json b/assets/locales/pending/ollama-model-no-tools.jsonnew file mode 100644index 0000000000..087498dad0--- /dev/null+++ b/assets/locales/pending/ollama-model-no-tools.json@@ -0,0 +1,5 @@+{+ "en": { "ui.agent_chat_model_no_tools": "{model} can't use SolidCraft's tools, so it can only chat. Pick a model with tool support." },+ "ja": { "ui.agent_chat_model_no_tools": "{model} は SolidCraft のツールを使えず、チャットのみ可能です。ツール対応のモデルを選んでください。" },+ "zh": { "ui.agent_chat_model_no_tools": "{model} 无法使用 SolidCraft 的工具,只能聊天。请选择支持工具的模型。" }+}diff --git a/crates/ui-egui/src/agent_chat/agents.rs b/crates/ui-egui/src/agent_chat/agents.rsindex 7931760779..8d989a9084 100644--- a/crates/ui-egui/src/agent_chat/agents.rs+++ b/crates/ui-egui/src/agent_chat/agents.rs@@ -106,6 +106,8 @@ pub struct AgentConfig {/// API: the endpoint (`…/v1`) and model.pub base_url: String,pub model: String,+ /// Added with the Ollama preset (even if its display name changes).+ pub ollama: bool,/// 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@@ -122,6 +124,7 @@ impl Default for AgentConfig {command: String::new(),base_url: String::new(),model: String::new(),+ ollama: false,key: false,request_timeout_s: DEFAULT_REQUEST_TIMEOUT_S,}diff --git a/crates/ui-egui/src/agent_chat/discover.rs b/crates/ui-egui/src/agent_chat/discover.rsindex 17663d4df6..0fd03560a9 100644--- a/crates/ui-egui/src/agent_chat/discover.rs+++ b/crates/ui-egui/src/agent_chat/discover.rs@@ -352,10 +352,93 @@ fn detect_in(dirs: &[PathBuf], home: Option<&Path>) -> Detection {d}+/// Query only the endpoint's origin; OpenAI-compatible paths such as `/v1` are unrelated.+#[cfg(not(target_arch = "wasm32"))]+fn api_origin(base_url: &str) -> Option<String> {+ let (scheme, rest) = base_url.trim().split_once("://")?;+ if !matches!(scheme, "http" | "https") {+ return None;+ }+ let authority = rest.split(['/', '?', '#']).next()?;+ if authority.is_empty() || authority.contains(['@', ' ']) || authority.len() > 2048 {+ return None;+ }+ Some(format!("{scheme}://{authority}"))+}++/// Blocking, best-effort Ollama probe. Call only on a background thread, without API keys.+#[cfg(not(target_arch = "wasm32"))]+pub(super) fn ollama_tools(http: &super::backend::HttpFn, base_url: &str, model: &str, known_ollama: bool) -> Option<bool> {+ use super::backend::HttpRequest;+ let origin = api_origin(base_url)?;+ let request = |method, path: &str, body| {+ let (status, bytes) = http(&HttpRequest {+ method,+ url: format!("{origin}/api/{path}"),+ headers: if method == "POST" { vec![("Content-Type".into(), "application/json".into())] } else { Vec::new() },+ body,+ timeout_s: 5,+ })+ .ok()?;+ if !(200..300).contains(&status) || bytes.len() > 4 * 1024 * 1024 {+ return None;+ }+ serde_json::from_slice::<serde_json::Value>(&bytes).ok()+ };+ if !known_ollama {+ let version = request("GET", "version", None)?;+ version.get("version")?.as_str()?;+ }+ let body = serde_json::to_vec(&serde_json::json!({"model": model})).ok()?;+ tools_capability(&request("POST", "show", Some(body))?)+}++/// Tool support is unknown unless Ollama returns a capabilities list of strings.+#[cfg(not(target_arch = "wasm32"))]+pub(super) fn tools_capability(value: &serde_json::Value) -> Option<bool> {+ let capabilities = value.get("capabilities")?.as_array()?;+ if capabilities.iter().any(|capability| !capability.is_string()) {+ return None;+ }+ Some(capabilities.iter().any(|capability| capability.as_str() == Some("tools")))+}+#[cfg(test)]mod tests {use super::*;+ #[test]+ fn ollama_capabilities_distinguish_tools_chat_and_unknown() {+ use serde_json::json;+ assert_eq!(tools_capability(&json!({"capabilities": ["completion", "tools"]})), Some(true));+ assert_eq!(tools_capability(&json!({"capabilities": ["completion"]})), Some(false));+ assert_eq!(tools_capability(&json!({"capabilities": []})), Some(false));+ for value in [json!({}), json!({"capabilities": null}), json!({"capabilities": [false]})] {+ assert_eq!(tools_capability(&value), None);+ }+ assert_eq!(api_origin("http://[::1]:11434/proxy/v1/").as_deref(), Some("http://[::1]:11434"));+ assert_eq!(api_origin("file:///tmp/model"), None);+ let http: super::super::backend::HttpFn = std::sync::Arc::new(|request| {+ assert_eq!(request.timeout_s, 5);+ match request.method {+ "GET" => {+ assert_eq!(request.url, "http://localhost:11434/api/version");+ Ok((200, br#"{"version":"0.0"}"#.to_vec()))+ }+ "POST" => {+ assert_eq!(request.url, "http://localhost:11434/api/show");+ assert_eq!(serde_json::from_slice::<serde_json::Value>(request.body.as_ref().unwrap()).unwrap(), json!({"model":"chat:4b"}));+ Ok((200, br#"{"capabilities":["completion"]}"#.to_vec()))+ }+ _ => Err("unexpected HTTP method".into()),+ }+ });+ assert_eq!(ollama_tools(&http, "http://localhost:11434/custom/v1", "chat:4b", false), Some(false));+ assert_eq!(ollama_tools(&http, "http://localhost:11434/v1", "chat:4b", true), Some(false));+ let unavailable: super::super::backend::HttpFn = std::sync::Arc::new(|_| Err("unavailable".into()));+ assert_eq!(ollama_tools(&unavailable, "http://localhost:11434/v1", "chat:4b", false), None);+ }+#[test]fn a_program_is_found_in_the_first_folder_that_has_it() {let root = std::env::temp_dir().join(format!("sc-agent-find-{}", std::process::id()));diff --git a/crates/ui-egui/src/agent_chat/mod.rs b/crates/ui-egui/src/agent_chat/mod.rsindex bcd943e3c1..10be0d4a94 100644--- a/crates/ui-egui/src/agent_chat/mod.rs+++ b/crates/ui-egui/src/agent_chat/mod.rs@@ -1614,6 +1614,8 @@ pub fn poll(app: &mut SolveApp, ctx: &egui::Context) {start_turn(app, text, image, at, files);}}+ #[cfg(not(target_arch = "wasm32"))]+ settings::poll_capabilities(app, ctx);pump_tools(app);if !app.agent_chat.held.is_empty() || app.agent_chat.state() == State::Busy {ctx.request_repaint_after(std::time::Duration::from_millis(250));@@ -1964,6 +1966,7 @@ pub fn status(app: &SolveApp) -> Value {"model": c.model,"providers": model_providers(app).iter().map(|(name, count)| json!({"name": name, "count": count})).collect::<Vec<_>>(),"provider": shown_provider(app),+ "modelWarning": settings::model_warning(app),"modes": c.modes.iter().map(|(id, name)| json!({"id": id, "name": name})).collect::<Vec<_>>(),"mode": c.mode,"open": c.open,diff --git a/crates/ui-egui/src/agent_chat/panel.rs b/crates/ui-egui/src/agent_chat/panel.rsindex 31a9811a5a..7e4ebd30b0 100644--- a/crates/ui-egui/src/agent_chat/panel.rs+++ b/crates/ui-egui/src/agent_chat/panel.rs@@ -1163,6 +1163,9 @@ fn switcher(app: &mut SolveApp, ui: &mut egui::Ui) {}}});+ if let Some(warning) = settings::model_warning(app) {+ ui.add(egui::Label::new(RichText::new(warning).color(t.warning).size(t.font_small)).wrap());+ }ui.horizontal(|ui| {let b = if app.agent_chat.state().running() {ui_kit::button(ui, tr("ui.agent_chat_stop"), ui_kit::Button::Normal).on_hover_text(tr("ui.agent_chat_stop_tip"))diff --git a/crates/ui-egui/src/agent_chat/settings.rs b/crates/ui-egui/src/agent_chat/settings.rsindex 58a8c06fdc..12cc04a089 100644--- a/crates/ui-egui/src/agent_chat/settings.rs+++ b/crates/ui-egui/src/agent_chat/settings.rs@@ -54,6 +54,92 @@ impl Test {pub struct State {pub add: Option<AddState>,pub tests: std::collections::HashMap<String, Test>,+ #[cfg(not(target_arch = "wasm32"))]+ capabilities: std::collections::HashMap<(String, String), Option<bool>>,+ #[cfg(not(target_arch = "wasm32"))]+ checking: Option<CapabilityCheck>,+}++#[cfg(not(target_arch = "wasm32"))]+struct CapabilityCheck {+ key: (String, String),+ rx: std::sync::mpsc::Receiver<Option<bool>>,+}++/// Poll one bounded background probe at a time. Failures are cached too.+#[cfg(not(target_arch = "wasm32"))]+pub(super) fn poll_capabilities(app: &mut SolveApp, ctx: &egui::Context) {+ use std::sync::mpsc::TryRecvError;+ let state = &mut app.agent_chat.settings;+ if let Some(check) = &state.checking {+ let result = match check.rx.try_recv() {+ Ok(value) => Some(value),+ Err(TryRecvError::Disconnected) => Some(None),+ Err(TryRecvError::Empty) => None,+ };+ if let Some(value) = result {+ if state.capabilities.len() >= 128 {+ state.capabilities.clear();+ }+ state.capabilities.insert(check.key.clone(), value);+ state.checking = None;+ }+ }+ if state.checking.is_some() {+ return;+ }+ let Some((key, known)) = capability_selection(app) else { return };+ if app.agent_chat.settings.capabilities.contains_key(&key) {+ return;+ }+ let Some(http) = app.services.agent_http.clone() else { return };+ if app.agent_chat.settings.capabilities.len() >= 128 {+ app.agent_chat.settings.capabilities.clear();+ }+ let (tx, rx) = std::sync::mpsc::channel();+ let query = key.clone();+ let wake = ctx.clone();+ if std::thread::Builder::new()+ .name("model-capabilities".into())+ .spawn(move || {+ let _ = tx.send(discover::ollama_tools(&http, &query.0, &query.1, known));+ wake.request_repaint();+ })+ .is_ok()+ {+ app.agent_chat.settings.checking = Some(CapabilityCheck { key, rx });+ } else {+ app.agent_chat.settings.capabilities.insert(key, None);+ }+}++#[cfg(not(target_arch = "wasm32"))]+fn capability_selection(app: &SolveApp) -> Option<((String, String), bool)> {+ let entry = agents::current(app)?;+ if entry.kind != Kind::Api {+ return None;+ }+ let model = if app.agent_chat.backend.is_none() || app.agent_chat.model.is_empty() { entry.model } else { app.agent_chat.model.clone() };+ if model.is_empty() || model.len() > 4096 || entry.base_url.len() > 4096 {+ return None;+ }+ let known = app.preferences.agents.iter().any(|a| a.id == entry.id && (a.ollama || a.name.eq_ignore_ascii_case("Ollama")));+ Some(((entry.base_url, model), known))+}++/// The same advisory text is used by the panel and the control channel.+pub(super) fn model_warning(app: &SolveApp) -> Option<String> {+ #[cfg(not(target_arch = "wasm32"))]+ if let Some((key, _)) = capability_selection(app) {+ return capability_warning(&key.1, app.agent_chat.settings.capabilities.get(&key).copied().flatten());+ }+ let _ = app;+ None+}++#[cfg(not(target_arch = "wasm32"))]+fn capability_warning(model: &str, tools: Option<bool>) -> Option<String> {+ (tools == Some(false)).then(|| trf("ui.agent_chat_model_no_tools", &[("model", model)]))}/// Open the Add agent dialog.@@ -645,6 +731,7 @@ fn add_agent(app: &mut SolveApp) -> Result<(), String> {}AddKind::Api => {c.kind = s.protocol.kind();+ c.ollama = s.protocol == Protocol::OpenAi && s.preset == 0;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);@@ -676,6 +763,61 @@ mod card_tests {use crate::scenario::{self, Harness};use serde_json::json;+ #[test]+ fn cached_model_warning_follows_endpoint_model_and_agent_selection() {+ let mut h = Harness::new();+ h.app.agent_chat.detection = Some(Default::default());+ h.app.preferences.agents.push(AgentConfig {+ id: "local".into(),+ kind: Kind::Api,+ base_url: "http://localhost:11434/v1".into(),+ model: "chat:4b".into(),+ ..Default::default()+ });+ use std::sync::{+ Arc,+ atomic::{AtomicUsize, Ordering},+ };+ use std::time::{Duration, Instant};+ let calls = Arc::new(AtomicUsize::new(0));+ let count = calls.clone();+ let ui_thread = std::thread::current().id();+ h.app.services.agent_http = Some(Arc::new(move |request| {+ assert_ne!(std::thread::current().id(), ui_thread);+ count.fetch_add(1, Ordering::SeqCst);+ Ok((200, if request.method == "GET" { br#"{"version":"0.0"}"#.to_vec() } else { br#"{"capabilities":["completion"]}"#.to_vec() }))+ }));+ poll_capabilities(&mut h.app, &h.ctx);+ let deadline = Instant::now() + Duration::from_secs(2);+ while h.app.agent_chat.settings.checking.is_some() && Instant::now() < deadline {+ std::thread::sleep(Duration::from_millis(1));+ poll_capabilities(&mut h.app, &h.ctx);+ }+ assert!(h.app.agent_chat.settings.checking.is_none());+ assert_eq!(calls.load(Ordering::SeqCst), 2);+ poll_capabilities(&mut h.app, &h.ctx);+ assert_eq!(calls.load(Ordering::SeqCst), 2, "cached selections do not probe again");+ assert_eq!(status(&h.app)["modelWarning"], capability_warning("chat:4b", Some(false)).unwrap());+ h.app.preferences.agents[0].model = "tools:8b".into();+ assert!(status(&h.app)["modelWarning"].is_null());+ h.app.preferences.agents[0].model = "chat:4b".into();+ h.app.preferences.agents[0].base_url = "http://localhost:1234/v1".into();+ assert!(status(&h.app)["modelWarning"].is_null());+ h.app.preferences.agents[0].base_url = "http://localhost:11434/v1".into();+ h.app.preferences.agents[0].kind = Kind::Acp;+ assert!(status(&h.app)["modelWarning"].is_null());+ }++ #[test]+ fn model_warning_only_for_explicitly_missing_tools() {+ assert_eq!(+ capability_warning("local:4b", Some(false)).as_deref(),+ Some("local:4b can't use SolidCraft's tools, so it can only chat. Pick a model with tool support.")+ );+ assert_eq!(capability_warning("local:4b", Some(true)), None);+ assert_eq!(capability_warning("local:4b", None), None);+ }+#[test]fn add_agent_card_retains_kind_handles_draft_and_validation() {let mut h = Harness::new();diff --git a/docs/agent-chat.md b/docs/agent-chat.mdindex 6642568711..57933574ee 100644--- a/docs/agent-chat.md+++ b/docs/agent-chat.md@@ -224,6 +224,13 @@ Grok Build also supports `XAI_API_KEY` for users who choose API authentication.endpoint's entry under **Agents**, where a change applies from the next request. A request thatruns out of time ends the message with the limit it hit and where to raise it.+For Ollama, choosing a model checks its reported capabilities in the background. If its+capabilities list lacks `tools`, a warning below the model picker explains that the model can+only chat and suggests choosing one with tool support. Results are cached in memory per base URL and+model, with a limit of 128 entries. SolidCraft recognises Ollama through `/api/version` at the+endpoint's origin or the Ollama preset. Failed checks and older servers without a capabilities+field show no warning. The check never blocks sending a message.+### An agent inside WSL (Windows)An agent installed inside WSL keeps its own settings, skills and sign-in there. Add it as adiff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex 269b515d24..48d81ef370 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -253,7 +253,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` + `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), `provider?` (which provider's models the model picker lists, when they come from several), `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`, `providers` (`name` and `count` of each, empty with one provider), `provider` (the one listed), `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), `provider?` (which provider's models the model picker lists, when they come from several), `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`, `modelWarning` (the model capability warning text, or `null` when unknown or tool support is reported; checked asynchronously and never blocks sending), `providers` (`name` and `count` of each, empty with one provider), `provider` (the one listed), `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) |