correct thinking modes for each model

src/server/request.rs

@@ -534,7 +534,7 @@ pub(super) fn parse_chat_request(
         return Err((400, format!("model is not installed and verified: {model}")));
     }
 
-    let reasoning_mode = request_reasoning(&request, requested_id)?;
+    let reasoning_mode = request_reasoning(&request, model, requested_id)?;
     let mut generation = config.generation_for(model, reasoning_mode);
     generation.max_generated_tokens = request
         .max_completion_tokens
@@ -594,31 +594,43 @@ pub(super) fn parse_chat_request(
 
 fn request_reasoning(
     request: &ChatRequest,
+    model: ModelChoice,
     model_id: &str,
 ) -> Result<ReasoningMode, (u16, String)> {
     let explicit_thinking = request
         .think
         .or_else(|| request.thinking.as_ref().and_then(thinking_enabled));
-    let mut reasoning = match request.reasoning_effort.as_deref() {
-        Some("max") => ReasoningMode::Max,
-        Some("none") => ReasoningMode::Direct,
-        Some("xhigh" | "high" | "medium" | "low" | "minimal") | None => ReasoningMode::High,
+    let explicit_effort = match request.reasoning_effort.as_deref() {
+        Some("none") => Some(ReasoningMode::Direct),
+        Some("low") => Some(ReasoningMode::Low),
+        Some("high") => Some(ReasoningMode::High),
+        Some("max") => Some(ReasoningMode::Max),
+        None => None,
         Some(value) => return Err((400, format!("unsupported reasoning_effort: {value}"))),
     };
-    if explicit_thinking == Some(false)
-        || (explicit_thinking.is_none()
-            && matches!(
-                model_id,
-                "deepseek-chat"
-                    | "glm-5.2-chat"
-                    | "glm-5.2-no-think"
-                    | "glm-5.2-nothink"
-                    | "glm-5.3-flash-chat"
-                    | "zai/glm-5.3-flash-chat"
-            ))
+    let direct_alias = matches!(
+        model_id,
+        "deepseek-chat"
+            | "glm-5.2-chat"
+            | "glm-5.2-no-think"
+            | "glm-5.2-nothink"
+            | "zai/glm-5.2-chat"
+    );
+    if (direct_alias && explicit_thinking == Some(true))
+        || ((direct_alias || explicit_thinking == Some(false))
+            && explicit_effort.is_some_and(|mode| mode != ReasoningMode::Direct))
+        || (explicit_thinking == Some(true) && explicit_effort == Some(ReasoningMode::Direct))
     {
-        reasoning = ReasoningMode::Direct;
+        return Err((400, "conflicting thinking controls".into()));
     }
+    let reasoning = if direct_alias || explicit_thinking == Some(false) {
+        ReasoningMode::Direct
+    } else {
+        explicit_effort.unwrap_or_else(|| model.default_reasoning_mode())
+    };
+    model
+        .validate_reasoning_mode(reasoning)
+        .map_err(|error| (400, error))?;
     Ok(reasoning)
 }
 
@@ -632,3 +644,70 @@ fn thinking_enabled(value: &Value) -> Option<bool> {
         })
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn request(effort: Option<&str>, thinking: Option<bool>) -> ChatRequest {
+        let mut value = json!({"messages": [{"role": "user", "content": "hello"}]});
+        if let Some(effort) = effort {
+            value["reasoning_effort"] = Value::String(effort.into());
+        }
+        if let Some(thinking) = thinking {
+            value["thinking"] = Value::Bool(thinking);
+        }
+        decode_chat_request(value).unwrap()
+    }
+
+    #[test]
+    fn reasoning_requests_preserve_each_models_exact_modes() {
+        let default = request(None, None);
+        assert_eq!(
+            request_reasoning(&default, ModelChoice::DeepSeekV4Flash0731, "").unwrap(),
+            ReasoningMode::Low
+        );
+        assert_eq!(
+            request_reasoning(&default, ModelChoice::DeepSeekV4Pro, "").unwrap(),
+            ReasoningMode::Low
+        );
+        assert_eq!(
+            request_reasoning(&default, ModelChoice::Glm52, "").unwrap(),
+            ReasoningMode::Max
+        );
+        assert_eq!(
+            request_reasoning(&default, ModelChoice::Glm53Flash, "").unwrap(),
+            ReasoningMode::Max
+        );
+
+        for (effort, mode) in [
+            ("none", ReasoningMode::Direct),
+            ("low", ReasoningMode::Low),
+            ("high", ReasoningMode::High),
+            ("max", ReasoningMode::Max),
+        ] {
+            let explicit = request(Some(effort), None);
+            for model in crate::model::MODEL_CHOICES {
+                let result = request_reasoning(&explicit, model, "");
+                if model.reasoning_modes().contains(&mode) {
+                    assert_eq!(result.unwrap(), mode);
+                } else {
+                    assert!(result.is_err());
+                }
+            }
+        }
+
+        assert!(request_reasoning(&request(Some("medium"), None), ModelChoice::Glm52, "").is_err());
+        assert!(
+            request_reasoning(&request(None, Some(false)), ModelChoice::Glm53Flash, "").is_err()
+        );
+        assert!(
+            request_reasoning(
+                &request(None, Some(true)),
+                ModelChoice::DeepSeekV4Flash0731,
+                "deepseek-chat"
+            )
+            .is_err()
+        );
+    }
+}