Fix ask_user starving the Rust SDK per-session event loop

Each session runs one `tokio::select!` loop in `rust/src/session.rs`.
Tool-call, permission, and elicitation callbacks arrive as notifications
and are `tokio::spawn`ed, so they run concurrently. But `ask_user`
arrives as a JSON-RPC request (`userInput.request`) and was handled by
`handle_request(...).await` inline in the select loop. While the user's
answer was pending (host backstop timeout: 5 min) the loop was parked and
could not drain the next notification, starving a sibling tool call
co-emitted in the same turn (e.g. `set_session_title` +
`ask_user` — github/copilot-experiences#12540) and freezing the UI.

Dispatch the `userInput.request` arm the same way as the other interactive
handlers: parse the params up front (keeping the inline INVALID_PARAMS
error for a missing `question`) then spawn a child task that runs
`UserInputHandler::handle` and sends the JSON-RPC response, mirroring the
permission-request spawn pattern. The loop now keeps draining while
`ask_user` is pending.

Add an e2e regression test (`ask_user` category) where the model emits
`set_marker` and `ask_user` in one turn; the user-input handler waits for
the sibling tool to fire before answering and asserts it observed the
tool while its own request was still pending. The test fails on the
inline-await code and passes once the handler is spawned.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 86146d70-7b81-497c-9d80-cd8dd8cf8a41

Author: pallaviraiturkar0

rust/src/session.rs

@@ -2263,37 +2263,57 @@ async fn handle_request(
                 .and_then(|p| p.get("allowFreeform"))
                 .and_then(|v| v.as_bool());
 
-            let handler_start = Instant::now();
-            let response = if let Some(user_input_handler) = handlers.user_input.as_ref() {
-                user_input_handler
-                    .handle(sid.clone(), question, choices, allow_freeform)
-                    .await
-            } else {
-                None
-            };
-            tracing::debug!(
-                elapsed_ms = handler_start.elapsed().as_millis(),
+            // Spawn the handler instead of awaiting it inline: `userInput.request`
+            // can stay pending for the full input backstop (minutes). Awaiting it
+            // inside the session's `tokio::select!` loop would park the loop and
+            // starve sibling tool-call/permission/elicitation notifications
+            // co-emitted in the same turn. Spawning mirrors how the
+            // notification-based interactive handlers are dispatched (see
+            // `handle_notification`) and keeps the loop draining concurrently.
+            let client = client.clone();
+            let user_input_handler = handlers.user_input.clone();
+            let request_id = request.id;
+            let span = tracing::error_span!(
+                "user_input_request_handler",
                 session_id = %sid,
-                "UserInputHandler::handle dispatch"
+                request_id = request_id
             );
+            tokio::spawn(
+                async move {
+                    let handler_start = Instant::now();
+                    let response = if let Some(user_input_handler) = user_input_handler.as_ref() {
+                        user_input_handler
+                            .handle(sid.clone(), question, choices, allow_freeform)
+                            .await
+                    } else {
+                        None
+                    };
+                    tracing::debug!(
+                        elapsed_ms = handler_start.elapsed().as_millis(),
+                        session_id = %sid,
+                        "UserInputHandler::handle dispatch"
+                    );
 
-            let rpc_result = match response {
-                Some(UserInputResponse {
-                    answer,
-                    was_freeform,
-                }) => serde_json::json!({
-                    "answer": answer,
-                    "wasFreeform": was_freeform,
-                }),
-                None => serde_json::json!({ "noResponse": true }),
-            };
-            let rpc_response = JsonRpcResponse {
-                jsonrpc: "2.0".to_string(),
-                id: request.id,
-                result: Some(rpc_result),
-                error: None,
-            };
-            let _ = client.send_response(&rpc_response).await;
+                    let rpc_result = match response {
+                        Some(UserInputResponse {
+                            answer,
+                            was_freeform,
+                        }) => serde_json::json!({
+                            "answer": answer,
+                            "wasFreeform": was_freeform,
+                        }),
+                        None => serde_json::json!({ "noResponse": true }),
+                    };
+                    let rpc_response = JsonRpcResponse {
+                        jsonrpc: "2.0".to_string(),
+                        id: request_id,
+                        result: Some(rpc_result),
+                        error: None,
+                    };
+                    let _ = client.send_response(&rpc_response).await;
+                }
+                .instrument(span),
+            );
         }
 
         "exitPlanMode.request" => {

rust/tests/e2e/ask_user.rs

@@ -1,11 +1,16 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use async_trait::async_trait;
 use github_copilot_sdk::handler::{
-    PermissionHandler, PermissionResult, UserInputHandler, UserInputResponse,
+    ApproveAllHandler, PermissionHandler, PermissionResult, UserInputHandler, UserInputResponse,
 };
-use github_copilot_sdk::{RequestId, SessionConfig, SessionId};
-use tokio::sync::mpsc;
+use github_copilot_sdk::tool::ToolHandler;
+use github_copilot_sdk::{
+    Error, RequestId, SessionConfig, SessionId, Tool, ToolInvocation, ToolResult,
+};
+use serde_json::json;
+use tokio::sync::{Notify, mpsc};
 
 use super::support::{
     DEFAULT_TEST_TOKEN, assistant_message_content, recv_with_timeout, with_e2e_context,
@@ -147,6 +152,77 @@ async fn should_handle_freeform_user_input_response() {
     .await;
 }
 
+/// Regression test for the per-session event-loop starvation bug where a pending
+/// `ask_user` (`userInput.request`) blocked the `tokio::select!` loop and starved
+/// a sibling tool call co-emitted in the same turn (github/copilot-experiences#12540).
+///
+/// The model emits both `set_marker` and `ask_user` in one assistant turn. The
+/// `set_marker` tool fires a `Notify`; the user-input handler waits on that
+/// `Notify` before answering. If `ask_user` were awaited inline, the loop could
+/// never dispatch the `set_marker` notification, so the handler would never
+/// observe the tool firing. With the handler spawned, both run concurrently and
+/// the handler observes the sibling tool while its own request is still pending.
+#[tokio::test]
+async fn ask_user_does_not_block_sibling_tool_call_in_same_turn() {
+    with_e2e_context(
+        "ask_user",
+        "ask_user_does_not_block_sibling_tool_call_in_same_turn",
+        |ctx| {
+            Box::pin(async move {
+                ctx.set_default_copilot_user();
+                let client = ctx.start_client().await;
+
+                // Fired by `set_marker` when the sibling tool executes.
+                let tool_fired = Arc::new(Notify::new());
+                // Reports whether the user-input handler observed the sibling tool
+                // firing while its own `ask_user` request was still pending.
+                let (observed_tx, mut observed_rx) = mpsc::unbounded_channel();
+
+                let user_input_handler = Arc::new(SiblingAwareUserInputHandler {
+                    tool_fired: tool_fired.clone(),
+                    observed_tx,
+                });
+                let tools = vec![set_marker_tool(tool_fired.clone())];
+
+                let session = client
+                    .create_session(
+                        SessionConfig::default()
+                            .with_github_token(DEFAULT_TEST_TOKEN)
+                            .with_permission_handler(Arc::new(ApproveAllHandler))
+                            .with_user_input_handler(
+                                user_input_handler as Arc<dyn UserInputHandler>,
+                            )
+                            .with_tools(tools),
+                    )
+                    .await
+                    .expect("create session");
+
+                session
+                    .send_and_wait(
+                        "Call set_marker with value 'go' and, at the same time, use the ask_user \
+                         tool to ask me to choose between 'Option A' and 'Option B'. Wait for my \
+                         answer before continuing.",
+                    )
+                    .await
+                    .expect("send")
+                    .expect("assistant message");
+
+                let observed =
+                    recv_with_timeout(&mut observed_rx, "user input handler observation").await;
+                assert!(
+                    observed,
+                    "ask_user handler must observe the sibling set_marker tool executing while \
+                     its own userInput.request is still pending (event loop must not be starved)"
+                );
+
+                session.disconnect().await.expect("disconnect session");
+                client.stop().await.expect("stop client");
+            })
+        },
+    )
+    .await;
+}
+
 #[derive(Debug)]
 struct RecordedUserInputRequest {
     session_id: SessionId,
@@ -204,3 +280,69 @@ impl PermissionHandler for RecordingUserInputHandler {
         PermissionResult::approve_once()
     }
 }
+
+/// A user-input handler that waits for a sibling tool to fire before answering,
+/// then reports whether it observed that tool while its own request was pending.
+struct SiblingAwareUserInputHandler {
+    tool_fired: Arc<Notify>,
+    observed_tx: mpsc::UnboundedSender<bool>,
+}
+
+#[async_trait]
+impl UserInputHandler for SiblingAwareUserInputHandler {
+    async fn handle(
+        &self,
+        _session_id: SessionId,
+        _question: String,
+        choices: Option<Vec<String>>,
+        _allow_freeform: Option<bool>,
+    ) -> Option<UserInputResponse> {
+        // Wait (bounded) for the sibling `set_marker` tool to execute. On the
+        // buggy inline-await path the event loop is parked here, the tool
+        // notification is never dispatched, and this times out.
+        let observed = tokio::time::timeout(Duration::from_secs(30), self.tool_fired.notified())
+            .await
+            .is_ok();
+        let _ = self.observed_tx.send(observed);
+
+        let answer = choices
+            .as_ref()
+            .and_then(|c| c.first())
+            .cloned()
+            .unwrap_or_else(|| "Option A".to_string());
+        Some(UserInputResponse {
+            answer,
+            was_freeform: false,
+        })
+    }
+}
+
+struct SetMarkerTool {
+    tool_fired: Arc<Notify>,
+}
+
+fn set_marker_tool(tool_fired: Arc<Notify>) -> Tool {
+    Tool::new("set_marker")
+        .with_description("Records a marker value")
+        .with_parameters(json!({
+            "type": "object",
+            "properties": {
+                "value": { "type": "string", "description": "Marker value" }
+            },
+            "required": ["value"]
+        }))
+        .with_handler(Arc::new(SetMarkerTool { tool_fired }))
+}
+
+#[async_trait]
+impl ToolHandler for SetMarkerTool {
+    async fn call(&self, invocation: ToolInvocation) -> Result<ToolResult, Error> {
+        let value = invocation
+            .arguments
+            .get("value")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or_default();
+        self.tool_fired.notify_one();
+        Ok(ToolResult::Text(format!("MARKER_{}", value.to_uppercase())))
+    }
+}

test/snapshots/ask_user/ask_user_does_not_block_sibling_tool_call_in_same_turn.yaml

@@ -0,0 +1,30 @@
+models:
+  - claude-sonnet-4.5
+conversations:
+  - messages:
+      - role: system
+        content: ${system}
+      - role: user
+        content: Call set_marker with value 'go' and, at the same time, use the ask_user tool to ask me to choose between
+          'Option A' and 'Option B'. Wait for my answer before continuing.
+      - role: assistant
+        tool_calls:
+          - id: toolcall_0
+            type: function
+            function:
+              name: set_marker
+              arguments: '{"value":"go"}'
+          - id: toolcall_1
+            type: function
+            function:
+              name: ask_user
+              arguments: '{"question":"Please choose between the following options:","choices":["Option A","Option B"]}'
+      - role: tool
+        tool_call_id: toolcall_0
+        content: MARKER_GO
+      - role: tool
+        tool_call_id: toolcall_1
+        content: "User selected: Option A"
+      - role: assistant
+        content: |-
+          The marker is set (MARKER_GO) and you selected **Option A**.