Reduce shutdown latency by parallelizing session destruction

.jules/bolt.md

@@ -0,0 +1,3 @@
+## 2025-05-15 - [Sequential session destruction in SDKs]
+**Learning:** All Copilot SDKs (Node.js, Python, Go, .NET) were initially implementing session destruction sequentially during client shutdown. This leads to a linear increase in shutdown time as the number of active sessions grows, especially when individual destructions involve retries and backoff.
+**Action:** Parallelize session cleanup using language-specific concurrency primitives (e.g., `Promise.all` in Node.js, `asyncio.gather` in Python, `Task.WhenAll` in .NET, or WaitGroups/Channels in Go) to ensure shutdown time remains constant and minimal.

nodejs/src/client.ts

@@ -298,8 +298,8 @@ export class CopilotClient {
     async stop(): Promise<Error[]> {
         const errors: Error[] = [];
 
-        // Destroy all active sessions with retry logic
-        for (const session of this.sessions.values()) {
+        // Destroy all active sessions in parallel with retry logic
+        const sessionPromises = Array.from(this.sessions.values()).map(async (session) => {
             const sessionId = session.sessionId;
             let lastError: Error | null = null;
 
@@ -321,12 +321,18 @@ export class CopilotClient {
             }
 
             if (lastError) {
-                errors.push(
-                    new Error(
-                        `Failed to destroy session ${sessionId} after 3 attempts: ${lastError.message}`
-                    )
+                return new Error(
+                    `Failed to destroy session ${sessionId} after 3 attempts: ${lastError.message}`
                 );
             }
+            return null;
+        });
+
+        const results = await Promise.all(sessionPromises);
+        for (const result of results) {
+            if (result instanceof Error) {
+                errors.push(result);
+            }
         }
         this.sessions.clear();