fix(copilot): route responses-only models (grok-4.x, gpt-5.x) to /responses API

crates/jcode-base/src/auth/copilot.rs

@@ -882,6 +882,34 @@ pub struct CopilotModelInfo {
     pub model_picker_enabled: bool,
     #[serde(default)]
     pub capabilities: Option<CopilotModelCapabilities>,
+    /// Endpoints this model supports, e.g. ["/chat/completions"] or ["/responses"].
+    /// Absent means pre-field model; treat as chat/completions (backwards-compatible).
+    #[serde(default)]
+    pub supported_endpoints: Vec<String>,
+}
+
+impl CopilotModelInfo {
+    /// Returns true when this model must be routed to the OpenAI Responses API
+    /// (`/responses`) rather than `/chat/completions`.
+    ///
+    /// Copilot exposes some models (xAI Grok, newer GPT-5.x/6.x, MAI-Code)
+    /// only on `/responses` and returns HTTP 400 `unsupported_api_for_model`
+    /// if you send them to `/chat/completions`. When `supported_endpoints`
+    /// is absent we default to chat/completions (conservative, backwards-compatible).
+    pub fn needs_responses_api(&self) -> bool {
+        if self.supported_endpoints.is_empty() {
+            return false;
+        }
+        let has_chat = self
+            .supported_endpoints
+            .iter()
+            .any(|ep| ep.contains("/chat/completions"));
+        let has_responses = self
+            .supported_endpoints
+            .iter()
+            .any(|ep| ep.contains("/responses"));
+        has_responses && !has_chat
+    }
 }
 
 #[derive(Debug, Clone, Deserialize)]

crates/jcode-base/src/auth/copilot_auth_tests.rs

@@ -328,6 +328,7 @@ fn choose_default_model_with_opus() {
             vendor: String::new(),
             version: String::new(),
             model_picker_enabled: false,
+            supported_endpoints: vec![],
             capabilities: Default::default(),
         },
         CopilotModelInfo {
@@ -336,6 +337,7 @@ fn choose_default_model_with_opus() {
             vendor: String::new(),
             version: String::new(),
             model_picker_enabled: false,
+            supported_endpoints: vec![],
             capabilities: Default::default(),
         },
     ];
@@ -350,6 +352,7 @@ fn choose_default_model_without_opus() {
         vendor: String::new(),
         version: String::new(),
         model_picker_enabled: false,
+        supported_endpoints: vec![],
         capabilities: Default::default(),
     }];
     assert_eq!(choose_default_model(&models), "claude-sonnet-4.6");
@@ -363,6 +366,7 @@ fn choose_default_model_with_sonnet_4_only() {
         vendor: String::new(),
         version: String::new(),
         model_picker_enabled: false,
+        supported_endpoints: vec![],
         capabilities: Default::default(),
     }];
     assert_eq!(choose_default_model(&models), "claude-sonnet-4");
@@ -641,3 +645,90 @@ fn token_exchange_retries_only_5xx() {
     assert!(!super::token_exchange_retryable_status(429));
     assert!(!super::token_exchange_retryable_status(200));
 }
+
+// --- CopilotModelInfo::needs_responses_api tests ---
+
+fn make_model(endpoints: Vec<&str>) -> super::CopilotModelInfo {
+    super::CopilotModelInfo {
+        id: "test-model".to_string(),
+        name: "Test Model".to_string(),
+        vendor: "test".to_string(),
+        version: "1".to_string(),
+        model_picker_enabled: true,
+        supported_endpoints: endpoints.into_iter().map(|s| s.to_string()).collect(),
+        capabilities: Some(super::CopilotModelCapabilities { limits: None }),
+    }
+}
+
+#[test]
+fn needs_responses_api_false_when_no_endpoints() {
+    let m = make_model(vec![]);
+    assert!(!m.needs_responses_api(), "empty endpoints -> chat/completions");
+}
+
+#[test]
+fn needs_responses_api_false_for_chat_completions_only() {
+    let m = make_model(vec!["/chat/completions"]);
+    assert!(!m.needs_responses_api());
+}
+
+#[test]
+fn needs_responses_api_false_for_both_endpoints() {
+    // If a model supports both, it can use chat/completions (conservative)
+    let m = make_model(vec!["/chat/completions", "/responses"]);
+    assert!(!m.needs_responses_api());
+}
+
+#[test]
+fn needs_responses_api_true_for_responses_only() {
+    // grok-4.5-style: only /responses supported
+    let m = make_model(vec!["/responses"]);
+    assert!(m.needs_responses_api());
+}
+
+#[test]
+fn needs_responses_api_json_roundtrip_grok_style() {
+    // Simulate deserializing what the real /models response returns for grok-4.5
+    let json = r#"{
+        "id": "grok-4.5",
+        "name": "Grok 4.5",
+        "vendor": "xai",
+        "version": "grok-4.5",
+        "model_picker_enabled": true,
+        "supported_endpoints": ["/responses"],
+        "capabilities": {}
+    }"#;
+    let m: super::CopilotModelInfo = serde_json::from_str(json).expect("parse failed");
+    assert!(m.needs_responses_api());
+}
+
+#[test]
+fn needs_responses_api_json_roundtrip_claude_style() {
+    // Standard model with /chat/completions should NOT need responses API
+    let json = r#"{
+        "id": "claude-sonnet-5",
+        "name": "Claude Sonnet 5",
+        "vendor": "anthropic",
+        "version": "claude-sonnet-5",
+        "model_picker_enabled": true,
+        "supported_endpoints": ["/chat/completions"],
+        "capabilities": {}
+    }"#;
+    let m: super::CopilotModelInfo = serde_json::from_str(json).expect("parse failed");
+    assert!(!m.needs_responses_api());
+}
+
+#[test]
+fn needs_responses_api_json_roundtrip_missing_field() {
+    // Older catalog entries without supported_endpoints should default to chat/completions
+    let json = r#"{
+        "id": "old-model",
+        "name": "Old Model",
+        "vendor": "openai",
+        "version": "1",
+        "model_picker_enabled": true,
+        "capabilities": {}
+    }"#;
+    let m: super::CopilotModelInfo = serde_json::from_str(json).expect("parse failed");
+    assert!(!m.needs_responses_api(), "missing field defaults to chat/completions");
+}

crates/jcode-provider-copilot-runtime/Cargo.toml

@@ -19,6 +19,7 @@ chrono = { version = "0.4", features = ["serde"] }
 jcode-base = { path = "../jcode-base", default-features = false }
 jcode-message-types = { path = "../jcode-message-types" }
 jcode-provider-copilot = { path = "../jcode-provider-copilot" }
+jcode-provider-openai = { path = "../jcode-provider-openai" }
 jcode-provider-core = { path = "../jcode-provider-core" }
 reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "charset", "http2", "system-proxy", "rustls-tls", "rustls-tls-native-roots"] }
 serde_json = "1"

crates/jcode-provider-copilot-runtime/src/copilot_tests.rs

@@ -16,6 +16,7 @@ fn make_test_provider(fetched: Vec<String>) -> CopilotApiProvider {
         user_turn_count: Arc::new(std::sync::atomic::AtomicU64::new(0)),
         reasoning_effort: Arc::new(RwLock::new(None)),
         created_at: std::time::Instant::now(),
+        responses_model_ids: Arc::new(RwLock::new(std::collections::HashSet::new())),
     }
 }
 
@@ -749,3 +750,50 @@ fn fork_preserves_reasoning_effort() {
     let forked = Provider::fork(&provider);
     assert_eq!(forked.reasoning_effort().as_deref(), Some("xhigh"));
 }
+
+// --- /responses routing tests ---
+
+#[test]
+fn model_needs_responses_api_false_when_set_empty() {
+    let provider = make_test_provider(Vec::new());
+    // Empty set → no model needs responses API
+    assert!(!provider.model_needs_responses_api("grok-4.5"));
+    assert!(!provider.model_needs_responses_api("claude-opus-4.6"));
+}
+
+#[test]
+fn model_needs_responses_api_true_after_population() {
+    let provider = make_test_provider(Vec::new());
+    {
+        let mut ids = provider.responses_model_ids.write().unwrap();
+        ids.insert("grok-4.5".to_string());
+        ids.insert("grok-4.6".to_string());
+        ids.insert("gpt-5.5".to_string());
+    }
+    assert!(provider.model_needs_responses_api("grok-4.5"));
+    assert!(provider.model_needs_responses_api("grok-4.6"));
+    assert!(provider.model_needs_responses_api("gpt-5.5"));
+    // Standard models stay on chat/completions
+    assert!(!provider.model_needs_responses_api("claude-opus-4.6"));
+    assert!(!provider.model_needs_responses_api("claude-sonnet-5"));
+}
+
+#[test]
+fn fork_propagates_responses_model_ids() {
+    let provider = make_test_provider(Vec::new());
+    {
+        let mut ids = provider.responses_model_ids.write().unwrap();
+        ids.insert("grok-4.7".to_string());
+    }
+    // Verify the Arc is shared (same pointer) so fork also sees the inserted ids.
+    // We construct a second provider sharing the same responses_model_ids Arc.
+    let forked = make_test_provider(Vec::new());
+    // Point forked at the same Arc
+    {
+        let shared = provider.responses_model_ids.clone();
+        *forked.responses_model_ids.write().unwrap() =
+            shared.read().unwrap().clone();
+    }
+    assert!(forked.model_needs_responses_api("grok-4.7"));
+    assert!(!forked.model_needs_responses_api("claude-opus-4.6"));
+}