Fix Rust E2E suite runtime

Replace the global Rust E2E lock with bounded replay-test concurrency so the suite no longer serializes every replay-backed case. Wait for disconnected-client tool removal before sending the follow-up multi-client prompt to keep the concurrent run deterministic.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: stephentoub

.github/workflows/rust-sdk-tests.yml

@@ -96,9 +96,10 @@ jobs:
       - name: cargo test
         timeout-minutes: 90
         env:
+          RUST_E2E_CONCURRENCY: 4
           COPILOT_HMAC_KEY: ${{ secrets.COPILOT_DEVELOPER_CLI_INTEGRATION_HMAC_KEY }}
           COPILOT_CLI_PATH: ${{ steps.setup-copilot.outputs.cli-path }}
-        run: cargo test --features test-support -- --test-threads=1 --nocapture
+        run: cargo test --features test-support -- --nocapture
 
   # Validates the `embedded-cli` build path on all three supported
   # platforms. This is the only place `build.rs` actually runs (the

rust/tests/e2e/multi_client.rs

@@ -237,7 +237,13 @@ async fn disconnecting_client_removes_its_tools() {
                     .expect("ephemeral answer");
                 assert!(assistant_message_content(&ephemeral).contains("EPHEMERAL_test2"));
 
+                let tools_removed = wait_for_event(
+                    session1.subscribe(),
+                    "ephemeral tool removal",
+                    |event| event.parsed_type() == SessionEventType::SessionToolsUpdated,
+                );
                 client2.force_stop();
+                tools_removed.await;
                 let after = session1
                     .send_and_wait(
                         "Use the stable_tool with input 'still_here'. Also try using ephemeral_tool if it is available.",

rust/tests/e2e/support.rs

@@ -16,9 +16,9 @@ use github_copilot_sdk::{
     SessionLifecycleEvent, Transport,
 };
 use serde_json::json;
-use tokio::sync::Mutex;
+use tokio::sync::Semaphore;
 
-static E2E_LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
+static E2E_CONCURRENCY: LazyLock<Semaphore> = LazyLock::new(|| Semaphore::new(e2e_concurrency()));
 
 pub const DEFAULT_TEST_TOKEN: &str = "rust-e2e-token";
 
@@ -28,7 +28,10 @@ pub async fn with_e2e_context<F>(category: &str, snapshot_name: &str, test: F)
 where
     F: for<'a> FnOnce(&'a mut E2eContext) -> TestFuture<'a>,
 {
-    let _guard = E2E_LOCK.lock().await;
+    let _permit = E2E_CONCURRENCY
+        .acquire()
+        .await
+        .expect("E2E concurrency semaphore should stay open");
     let mut ctx = E2eContext::new(category, snapshot_name)
         .await
         .unwrap_or_else(|err| panic!("create E2E context: {err}"));
@@ -452,6 +455,14 @@ fn default_test_timeout() -> Duration {
     }
 }
 
+fn e2e_concurrency() -> usize {
+    std::env::var("RUST_E2E_CONCURRENCY")
+        .ok()
+        .and_then(|value| value.parse::<usize>().ok())
+        .filter(|&value| value > 0)
+        .unwrap_or(4)
+}
+
 pub fn get_system_message(exchange: &serde_json::Value) -> String {
     exchange
         .get("request")