SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
fix(ai-chat): replay with reasoning_effort none when OpenAI refuses tools (#3798) (#3817)
rlartot68e418608060
diff --git a/crates/ui-egui/src/agent_chat/api_client.rs b/crates/ui-egui/src/agent_chat/api_client.rsindex 39704695a9..3fb584c5ec 100644--- a/crates/ui-egui/src/agent_chat/api_client.rs+++ b/crates/ui-egui/src/agent_chat/api_client.rs@@ -75,7 +75,17 @@ impl ApiBackend {let stop = cancel.clone();let wake: Arc<dyn Fn() + Send + Sync> = Arc::from(ctx.wake);std::thread::spawn(move || {- let mut w = Worker { cfg, mcp, next: 0, tools: Vec::new(), history: Vec::new(), events: ev_tx, wake, cancel: stop };+ let mut w = Worker {+ cfg,+ mcp,+ next: 0,+ tools: Vec::new(),+ history: Vec::new(),+ events: ev_tx,+ wake,+ cancel: stop,+ no_reasoning: Default::default(),+ };w.run(cmd_rx);});Ok(ApiBackend { cmds: Some(cmd_tx), events, cancel, mcp: handle })@@ -137,6 +147,8 @@ struct Worker {events: Sender<Event>,wake: Arc<dyn Fn() + Send + Sync>,cancel: Arc<AtomicBool>,+ /// Set once the endpoint refused tools together with a reasoning effort: later requests ask for none.+ no_reasoning: std::cell::Cell<bool>,}impl Worker {@@ -322,7 +334,28 @@ impl Worker {let mut body = json!({"model": self.cfg.model, "messages": self.history});if !self.tools.is_empty() {body["tools"] = Value::Array(self.tools.clone());+ if self.no_reasoning.get() {+ body["reasoning_effort"] = json!("none");+ }+ }+ let (status, v) = self.post(&body)?;+ // Some OpenAI models refuse function tools on this endpoint unless the reasoning effort is+ // "none" (HTTP 400 naming `reasoning_effort`): ask again once with it, and keep it for the+ // next requests.+ let refused = status == 400 && !self.tools.is_empty() && !self.no_reasoning.get() && http_error(status, &v).contains("reasoning_effort");+ if refused {+ self.no_reasoning.set(true);+ body["reasoning_effort"] = json!("none");+ let (status, v) = self.post(&body)?;+ return if status == 200 { Ok(v) } else { Err(http_error(status, &v)) };+ }+ if status != 200 {+ return Err(http_error(status, &v));}+ Ok(v)+ }++ fn post(&self, body: &Value) -> Result<(u16, Value), String> {let mut headers = vec![("Content-Type".to_string(), "application/json".to_string())];if let Some(k) = &self.cfg.key {headers.push(("Authorization".into(), format!("Bearer {k}")));@@ -351,11 +384,7 @@ impl Worker {Err(_) => return Err("the request ended without an answer".into()),}};- let v: Value = serde_json::from_slice(&bytes).unwrap_or(Value::Null);- if status != 200 {- return Err(http_error(status, &v));- }- Ok(v)+ Ok((status, serde_json::from_slice(&bytes).unwrap_or(Value::Null)))}}@@ -776,4 +805,63 @@ mod tests {let ctx = StartContext { cwd: std::env::temp_dir(), bridge: None, tools: None, wake: Box::new(|| {}) };assert!(ApiBackend::start(cfg, ctx).is_err());}++ /// A worker with one function tool whose endpoint answers each POST with the next scripted+ /// (status, body); the requests it received are returned too.+ fn scripted_worker(answers: Vec<(u16, Value)>) -> (Worker, Arc<std::sync::Mutex<Vec<Value>>>) {+ let answers = std::sync::Mutex::new(answers.into_iter().rev().collect::<Vec<_>>());+ let seen = Arc::new(std::sync::Mutex::new(Vec::<Value>::new()));+ let log = seen.clone();+ let http: HttpFn = Arc::new(move |r: &HttpRequest| {+ log.lock().unwrap().push(serde_json::from_slice(r.body.as_deref().unwrap()).unwrap());+ let (status, v) = answers.lock().unwrap().pop().expect("no request beyond the script");+ Ok((status, v.to_string().into_bytes()))+ });+ let cfg = ApiConfig { name: "Test".into(), base_url: "http://localhost:1/v1".into(), model: "m".into(), key: Some("sk-secret".into()), http };+ let (events, _rx) = channel();+ let w = Worker {+ cfg,+ mcp: None,+ next: 0,+ tools: vec![json!({"type": "function", "function": {"name": "measure"}})],+ history: vec![json!({"role": "user", "content": "hi"})],+ events,+ wake: Arc::new(|| {}),+ cancel: Arc::new(AtomicBool::new(false)),+ no_reasoning: Default::default(),+ };+ (w, seen)+ }++ fn refusal() -> (u16, Value) {+ (400, json!({"error": {"message": "Function tools with reasoning_effort are not supported for gpt-6.1-sol in /v1/chat/completions."}}))+ }++ /// Newer OpenAI models answer 400 to function tools without `reasoning_effort: none`: the+ /// request is replayed once with it, and the next ones carry it at once.+ #[test]+ fn a_refusal_of_tools_with_reasoning_effort_is_replayed_once_with_none() {+ let ok = json!({"choices": [{"message": {"role": "assistant", "content": "Done."}}]});+ let (w, seen) = scripted_worker(vec![refusal(), (200, ok.clone()), (200, ok.clone())]);+ assert_eq!(w.request().unwrap(), ok);+ assert_eq!(w.request().unwrap(), ok);+ let sent = seen.lock().unwrap();+ assert_eq!(sent.len(), 3);+ assert!(sent[0].get("reasoning_effort").is_none());+ assert_eq!(sent[1]["reasoning_effort"], "none");+ assert_eq!(sent[2]["reasoning_effort"], "none");+ }++ /// No loop: a second refusal is the error, after exactly two requests; the message shows the+ /// endpoint's words but never the key; an unrelated 400 is not replayed at all.+ #[test]+ fn the_replay_happens_once_and_only_for_that_refusal() {+ let (w, seen) = scripted_worker(vec![refusal(), refusal()]);+ let e = w.request().unwrap_err();+ assert!(e.starts_with("HTTP 400") && e.contains("reasoning_effort") && !e.contains("sk-secret"), "{e}");+ assert_eq!(seen.lock().unwrap().len(), 2);+ let (w, seen) = scripted_worker(vec![(400, json!({"error": {"message": "context length exceeded"}}))]);+ assert!(w.request().unwrap_err().contains("context length"));+ assert_eq!(seen.lock().unwrap().len(), 1);+ }}