Add support for GitHub Copilot /responses endpoint (#40762)

Add support for GithubCopilot /responses endpoint. This gives the
copilot chat provider the ability to use the new GPT-5 codex model and
any other model that lacks support for /chat/copmletions endpoint.

Closes #38858 

Release Notes:

- Add support for GithubCopilot /responses endpoint.

# Added
1. copilot_response.rs that has the /response endpoint types
2. uses response endpoint if model does not support /chat/completions.
3. new into_copilot_response() to map LanguageCompletionEvents to
Request.
4. new map_stream() to map response stream event to
LanguageCompletionEvents and tests.
5. Fixed a bug where trying to parse response for non streaming for
/chat/completion was failing

# Notes
There is a pr open - #39989
for adding /response support for OpenAi and OpenAi compatible API.
Altough they share some similarities (copilot api seems to mirror openAi
directly) ive simplified some stuff and tried to keep it the same with
the vscode-chat implementation where possible. There might be a case for
code reuse but i think keeping them separate for now should be ok.

# Tool Calls
<img width="716" height="670" alt="Screenshot from 2025-10-15 17-12-30"
src="https://github.com/user-attachments/assets/14e88a52-ba8b-4209-8f78-73d15034b1e0"
/>

# Image
<img width="923" height="494" alt="Screenshot from 2025-10-21 02-02-26"
src="https://github.com/user-attachments/assets/b96ce97c-331e-45cb-b5b1-7aa10ed387b4"
/>

Author: somtooo

crates/copilot/src/copilot.rs

@@ -1,5 +1,6 @@
 pub mod copilot_chat;
 mod copilot_completion_provider;
+pub mod copilot_responses;
 pub mod request;
 mod sign_in;
 

crates/copilot/src/copilot_chat.rs

@@ -15,6 +15,8 @@ use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use itertools::Itertools;
 use paths::home_dir;
 use serde::{Deserialize, Serialize};
+
+use crate::copilot_responses as responses;
 use settings::watch_config_dir;
 
 pub const COPILOT_OAUTH_ENV_VAR: &str = "GH_COPILOT_TOKEN";
@@ -42,10 +44,14 @@ impl CopilotChatConfiguration {
         }
     }
 
-    pub fn api_url_from_endpoint(&self, endpoint: &str) -> String {
+    pub fn chat_completions_url_from_endpoint(&self, endpoint: &str) -> String {
         format!("{}/chat/completions", endpoint)
     }
 
+    pub fn responses_url_from_endpoint(&self, endpoint: &str) -> String {
+        format!("{}/responses", endpoint)
+    }
+
     pub fn models_url_from_endpoint(&self, endpoint: &str) -> String {
         format!("{}/models", endpoint)
     }
@@ -71,6 +77,14 @@ pub enum Role {
     System,
 }
 
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+pub enum ModelSupportedEndpoint {
+    #[serde(rename = "/chat/completions")]
+    ChatCompletions,
+    #[serde(rename = "/responses")]
+    Responses,
+}
+
 #[derive(Deserialize)]
 struct ModelSchema {
     #[serde(deserialize_with = "deserialize_models_skip_errors")]
@@ -109,6 +123,8 @@ pub struct Model {
     // reached. Zed does not currently implement this behaviour
     is_chat_fallback: bool,
     model_picker_enabled: bool,
+    #[serde(default)]
+    supported_endpoints: Vec<ModelSupportedEndpoint>,
 }
 
 #[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
@@ -224,6 +240,16 @@ impl Model {
     pub fn tokenizer(&self) -> Option<&str> {
         self.capabilities.tokenizer.as_deref()
     }
+
+    pub fn supports_response(&self) -> bool {
+        self.supported_endpoints.len() > 0
+            && !self
+                .supported_endpoints
+                .contains(&ModelSupportedEndpoint::ChatCompletions)
+            && self
+                .supported_endpoints
+                .contains(&ModelSupportedEndpoint::Responses)
+    }
 }
 
 #[derive(Serialize, Deserialize)]
@@ -253,7 +279,7 @@ pub enum Tool {
     Function { function: Function },
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "lowercase")]
 pub enum ToolChoice {
     Auto,
@@ -346,7 +372,7 @@ pub struct Usage {
 
 #[derive(Debug, Deserialize)]
 pub struct ResponseChoice {
-    pub index: usize,
+    pub index: Option<usize>,
     pub finish_reason: Option<String>,
     pub delta: Option<ResponseDelta>,
     pub message: Option<ResponseDelta>,
@@ -359,10 +385,9 @@ pub struct ResponseDelta {
     #[serde(default)]
     pub tool_calls: Vec<ToolCallChunk>,
 }
-
 #[derive(Deserialize, Debug, Eq, PartialEq)]
 pub struct ToolCallChunk {
-    pub index: usize,
+    pub index: Option<usize>,
     pub id: Option<String>,
     pub function: Option<FunctionChunk>,
 }
@@ -554,13 +579,47 @@ impl CopilotChat {
         is_user_initiated: bool,
         mut cx: AsyncApp,
     ) -> Result<BoxStream<'static, Result<ResponseEvent>>> {
+        let (client, token, configuration) = Self::get_auth_details(&mut cx).await?;
+
+        let api_url = configuration.chat_completions_url_from_endpoint(&token.api_endpoint);
+        stream_completion(
+            client.clone(),
+            token.api_key,
+            api_url.into(),
+            request,
+            is_user_initiated,
+        )
+        .await
+    }
+
+    pub async fn stream_response(
+        request: responses::Request,
+        is_user_initiated: bool,
+        mut cx: AsyncApp,
+    ) -> Result<BoxStream<'static, Result<responses::StreamEvent>>> {
+        let (client, token, configuration) = Self::get_auth_details(&mut cx).await?;
+
+        let api_url = configuration.responses_url_from_endpoint(&token.api_endpoint);
+        responses::stream_response(
+            client.clone(),
+            token.api_key,
+            api_url,
+            request,
+            is_user_initiated,
+        )
+        .await
+    }
+
+    async fn get_auth_details(
+        cx: &mut AsyncApp,
+    ) -> Result<(Arc<dyn HttpClient>, ApiToken, CopilotChatConfiguration)> {
         let this = cx
             .update(|cx| Self::global(cx))
             .ok()
             .flatten()
             .context("Copilot chat is not enabled")?;
 
-        let (oauth_token, api_token, client, configuration) = this.read_with(&cx, |this, _| {
+        let (oauth_token, api_token, client, configuration) = this.read_with(cx, |this, _| {
             (
                 this.oauth_token.clone(),
                 this.api_token.clone(),
@@ -572,28 +631,20 @@ impl CopilotChat {
         let oauth_token = oauth_token.context("No OAuth token available")?;
 
         let token = match api_token {
-            Some(api_token) if api_token.remaining_seconds() > 5 * 60 => api_token.clone(),
+            Some(api_token) if api_token.remaining_seconds() > 5 * 60 => api_token,
             _ => {
                 let token_url = configuration.token_url();
                 let token =
                     request_api_token(&oauth_token, token_url.into(), client.clone()).await?;
-                this.update(&mut cx, |this, cx| {
+                this.update(cx, |this, cx| {
                     this.api_token = Some(token.clone());
                     cx.notify();
                 })?;
                 token
             }
         };
 
-        let api_url = configuration.api_url_from_endpoint(&token.api_endpoint);
-        stream_completion(
-            client.clone(),
-            token.api_key,
-            api_url.into(),
-            request,
-            is_user_initiated,
-        )
-        .await
+        Ok((client, token, configuration))
     }
 
     pub fn set_configuration(