provider: fix Mistral 422 (#261) and make SSE idle timeout configurable (#196)

#261: Mistral strictly enforces the OpenAI schema and 422s on the
non-standard reasoning_content message field and top-level thinking
request field. Add strict_openai_schema_endpoint() (matches the mistral
profile id or *.mistral.ai api_base) and suppress both reasoning_content
injection and the thinking field for those endpoints.

#196: Replace the hardcoded 180s SSE_CHUNK_TIMEOUT with a configurable
[provider] stream_idle_timeout_secs (default 180), overridable via
JCODE_STREAM_IDLE_TIMEOUT_SECS, so slow reasoning models that think
silently for minutes don't trip a premature timeout.

Author: 1jehuang

crates/jcode-base/src/config/default_file.rs

@@ -230,6 +230,11 @@ cross_provider_failover = "countdown"
 # Copilot premium mode: "normal" (default), "one" (first msg only), "zero" (all free)
 # Set to "zero" if you have premium Copilot and want free requests
 # copilot_premium = "zero"
+# Max seconds to wait for streaming data before timing out a request with no
+# data received. Raise this for slow reasoning models (e.g. DeepSeek) that think
+# silently for minutes before emitting tokens. Default: 180.
+# Also overridable per-launch via JCODE_STREAM_IDLE_TIMEOUT_SECS.
+# stream_idle_timeout_secs = 600
 
 [ambient]
 # Ambient mode: background agent that maintains your codebase

crates/jcode-base/src/config/env_overrides.rs

@@ -548,6 +548,13 @@ impl Config {
                 self.provider.same_provider_account_failover = enabled;
             }
         }
+        if let Ok(v) = std::env::var("JCODE_STREAM_IDLE_TIMEOUT_SECS") {
+            if let Ok(parsed) = v.trim().parse::<u64>() {
+                if parsed > 0 {
+                    self.provider.stream_idle_timeout_secs = parsed;
+                }
+            }
+        }
 
         // Copilot premium mode: env var overrides config
         // If set in config but not in env, propagate config -> env

crates/jcode-base/src/provider/openrouter.rs

@@ -1185,6 +1185,20 @@ impl OpenRouterProvider {
         }
     }
 
+    /// Detect providers that strictly enforce the OpenAI-compatible schema and
+    /// reject the non-standard `reasoning_content` message field and top-level
+    /// `thinking` request field. Mistral's API returns 422 "Extra inputs are
+    /// not permitted" when either is present (issue #261).
+    fn strict_openai_schema_endpoint(profile_id: Option<&str>, api_base: &str) -> bool {
+        if profile_id
+            .map(|id| id.eq_ignore_ascii_case("mistral"))
+            .unwrap_or(false)
+        {
+            return true;
+        }
+        api_base.to_ascii_lowercase().contains("mistral.ai")
+    }
+
     pub fn new() -> Result<Self> {
         let autodetected_profile = autodetected_openai_compatible_profile();
         let api_base = configured_api_base();

crates/jcode-base/src/provider/openrouter_provider_impl.rs

@@ -25,6 +25,16 @@ impl Provider for OpenRouterProvider {
         let include_reasoning_content =
             thinking_enabled == Some(true) || (allow_reasoning && Self::is_kimi_model(&model));
 
+        // Some OpenAI-compatible providers (e.g. Mistral) strictly enforce the
+        // OpenAI schema and reject the non-standard `reasoning_content` message
+        // field and top-level `thinking` request field with a 422 error
+        // ("Extra inputs are not permitted"). Suppress both for those endpoints
+        // regardless of any thinking override (issue #261).
+        let strict_openai_schema =
+            Self::strict_openai_schema_endpoint(self.profile_id.as_deref(), &self.api_base);
+        let allow_reasoning = allow_reasoning && !strict_openai_schema;
+        let include_reasoning_content = include_reasoning_content && !strict_openai_schema;
+
         let mut effective_messages: Vec<Message> = messages.to_vec();
         let cache_supported = self.model_supports_cache(&model).await;
         let cache_control_added = if cache_supported {
@@ -548,8 +558,11 @@ impl Provider for OpenRouterProvider {
         }
 
         // Optional thinking override for OpenRouter (provider-specific).
+        // Skip for strict OpenAI-schema endpoints (e.g. Mistral) which reject
+        // the non-standard top-level `thinking` field with a 422 (issue #261).
         if let Some(enable) = thinking_enabled
             && !sent_reasoning_config
+            && !strict_openai_schema
         {
             request["thinking"] = serde_json::json!({
                 "type": if enable { "enabled" } else { "disabled" }

crates/jcode-base/src/provider/openrouter_sse_stream.rs

@@ -187,10 +187,19 @@ async fn stream_response(
 
     let mut stream = OpenRouterStream::new(response.bytes_stream(), model.clone(), provider_pin);
 
-    const SSE_CHUNK_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(180);
+    // Idle timeout between streamed chunks. Configurable so slow reasoning
+    // models (e.g. DeepSeek) that think silently for minutes before emitting
+    // tokens don't trip a premature timeout (issue #196). Resolved from
+    // `[provider] stream_idle_timeout_secs` / `JCODE_STREAM_IDLE_TIMEOUT_SECS`,
+    // defaulting to 180s.
+    let idle_timeout_secs = crate::config::config()
+        .provider
+        .stream_idle_timeout_secs
+        .max(1);
+    let sse_chunk_timeout = std::time::Duration::from_secs(idle_timeout_secs);
 
     loop {
-        let event = match tokio::time::timeout(SSE_CHUNK_TIMEOUT, stream.next()).await {
+        let event = match tokio::time::timeout(sse_chunk_timeout, stream.next()).await {
             Ok(Some(Ok(event))) => event,
             Ok(Some(Err(e))) => anyhow::bail!(
                 "OpenAI-compatible stream error\n  endpoint: {}\n  model: {}\n  auth: {}\n  error: {}",
@@ -201,12 +210,16 @@ async fn stream_response(
             ),
             Ok(None) => break, // stream ended normally
             Err(_) => {
-                crate::logging::warn("OpenRouter SSE stream timed out (no data for 180s)");
+                crate::logging::warn(&format!(
+                    "OpenRouter SSE stream timed out (no data for {}s)",
+                    idle_timeout_secs
+                ));
                 anyhow::bail!(
-                    "OpenAI-compatible stream timeout\n  endpoint: {}\n  model: {}\n  auth: {}\n  timeout: no data received for 180 seconds\n{}",
+                    "OpenAI-compatible stream timeout\n  endpoint: {}\n  model: {}\n  auth: {}\n  timeout: no data received for {} seconds\n{}",
                     url,
                     model,
                     auth.label(),
+                    idle_timeout_secs,
                     local_endpoint_troubleshooting_hint(&api_base, &model)
                 );
             }

crates/jcode-base/src/provider/openrouter_tests.rs

@@ -1505,3 +1505,45 @@ fn test_endpoint_detail_string() {
         detail
     );
 }
+
+#[test]
+fn strict_openai_schema_endpoint_detects_mistral_profile() {
+    // Mistral direct profile rejects non-standard reasoning_content/thinking
+    // fields with a 422 (issue #261), so it must be flagged strict.
+    assert!(OpenRouterProvider::strict_openai_schema_endpoint(
+        Some("mistral"),
+        "https://api.mistral.ai/v1"
+    ));
+    assert!(OpenRouterProvider::strict_openai_schema_endpoint(
+        Some("MISTRAL"),
+        "https://example.com/v1"
+    ));
+}
+
+#[test]
+fn strict_openai_schema_endpoint_detects_mistral_api_base() {
+    assert!(OpenRouterProvider::strict_openai_schema_endpoint(
+        None,
+        "https://api.mistral.ai/v1"
+    ));
+    assert!(OpenRouterProvider::strict_openai_schema_endpoint(
+        Some("custom"),
+        "https://API.MISTRAL.AI/v1"
+    ));
+}
+
+#[test]
+fn strict_openai_schema_endpoint_allows_other_providers() {
+    assert!(!OpenRouterProvider::strict_openai_schema_endpoint(
+        Some("deepseek"),
+        "https://api.deepseek.com"
+    ));
+    assert!(!OpenRouterProvider::strict_openai_schema_endpoint(
+        None,
+        "https://openrouter.ai/api/v1"
+    ));
+    assert!(!OpenRouterProvider::strict_openai_schema_endpoint(
+        Some("openai"),
+        "https://api.openai.com/v1"
+    ));
+}

crates/jcode-config-types/src/lib.rs

@@ -727,6 +727,11 @@ pub struct ProviderConfig {
     /// Copilot premium request mode: "normal", "one", or "zero"
     /// "zero" means all requests are free (no premium requests consumed)
     pub copilot_premium: Option<String>,
+    /// Max seconds to wait for streaming data before timing out a request with
+    /// no data received. Raise this for slow reasoning models (e.g. DeepSeek)
+    /// that think silently for minutes before emitting tokens. Default: 180.
+    /// Overridable per-launch via `JCODE_STREAM_IDLE_TIMEOUT_SECS`.
+    pub stream_idle_timeout_secs: u64,
 }
 
 impl Default for ProviderConfig {
@@ -744,6 +749,7 @@ impl Default for ProviderConfig {
             cross_provider_failover: CrossProviderFailoverMode::Countdown,
             same_provider_account_failover: true,
             copilot_premium: None,
+            stream_idle_timeout_secs: 180,
         }
     }
 }