Restore shutdown notification coverage

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

Author: stephentoub

dotnet/test/SessionTests.cs

@@ -248,6 +248,7 @@ public async Task Should_Receive_Session_Events()
         var session = await CreateSessionAsync();
         var receivedEvents = new List<SessionEvent>();
         var idleReceived = new TaskCompletionSource<bool>();
+        var shutdownReceived = new TaskCompletionSource<bool>();
 
         session.On(evt =>
         {
@@ -256,6 +257,10 @@ public async Task Should_Receive_Session_Events()
             {
                 idleReceived.TrySetResult(true);
             }
+            else if (evt is SessionShutdownEvent)
+            {
+                shutdownReceived.TrySetResult(true);
+            }
         });
 
         // Send a message to trigger events
@@ -276,8 +281,10 @@ public async Task Should_Receive_Session_Events()
         Assert.NotNull(assistantMessage);
         Assert.Contains("300", assistantMessage!.Data.Content);
 
-        // Shut down session (sends RPC without clearing handlers), then dispose
+        // Shut down session and verify shutdown event is received
         await session.ShutdownAsync();
+        await shutdownReceived.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        Assert.Contains(receivedEvents, evt => evt is SessionShutdownEvent);
         await session.DisposeAsync();
     }
 

go/internal/e2e/session_test.go

@@ -594,13 +594,19 @@ func TestSession(t *testing.T) {
 		}
 
 		var receivedEvents []copilot.SessionEvent
-		idle := make(chan bool)
+		idle := make(chan struct{}, 1)
+		shutdown := make(chan struct{}, 1)
 
 		session.On(func(event copilot.SessionEvent) {
 			receivedEvents = append(receivedEvents, event)
 			if event.Type == "session.idle" {
 				select {
-				case idle <- true:
+				case idle <- struct{}{}:
+				default:
+				}
+			} else if event.Type == "session.shutdown" {
+				select {
+				case shutdown <- struct{}{}:
 				default:
 				}
 			}
@@ -657,10 +663,24 @@ func TestSession(t *testing.T) {
 			t.Errorf("Expected assistant message to contain '300', got %v", assistantMessage.Data.Content)
 		}
 
-		// Shut down session (sends RPC without clearing handlers), then destroy
+		// Shut down session and verify shutdown event is received
 		if err := session.Shutdown(); err != nil {
 			t.Fatalf("Failed to shut down session: %v", err)
 		}
+		select {
+		case <-shutdown:
+		case <-time.After(5 * time.Second):
+			t.Fatal("Timed out waiting for session.shutdown")
+		}
+		hasShutdown := false
+		for _, evt := range receivedEvents {
+			if evt.Type == "session.shutdown" {
+				hasShutdown = true
+			}
+		}
+		if !hasShutdown {
+			t.Error("Expected to receive session.shutdown event")
+		}
 		if err := session.Destroy(); err != nil {
 			t.Fatalf("Failed to destroy session: %v", err)
 		}

go/session_test.go

@@ -119,3 +119,132 @@ func TestSession_On(t *testing.T) {
 		}
 	})
 }
+
+func TestSession_Shutdown(t *testing.T) {
+	t.Run("shutdown event dispatches to handlers", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var received []SessionEvent
+		session.On(func(event SessionEvent) {
+			received = append(received, event)
+		})
+
+		session.dispatchEvent(SessionEvent{Type: "session.shutdown"})
+
+		if len(received) != 1 {
+			t.Fatalf("Expected 1 event, got %d", len(received))
+		}
+		if received[0].Type != "session.shutdown" {
+			t.Errorf("Expected session.shutdown event, got %s", received[0].Type)
+		}
+	})
+
+	t.Run("handlers still active after shutdown flag set", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var received []SessionEvent
+		session.On(func(event SessionEvent) {
+			received = append(received, event)
+		})
+
+		// Simulate what Shutdown() does: set the flag
+		session.isShutdown.Store(true)
+
+		// Handlers should still be active — Shutdown does not clear them
+		session.dispatchEvent(SessionEvent{Type: "session.shutdown"})
+
+		if len(received) != 1 {
+			t.Fatalf("Expected 1 event after shutdown, got %d", len(received))
+		}
+		if received[0].Type != "session.shutdown" {
+			t.Errorf("Expected session.shutdown, got %s", received[0].Type)
+		}
+	})
+
+	t.Run("shutdown idempotency via atomic flag", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		// First swap should return false (was not shut down)
+		if session.isShutdown.Swap(true) {
+			t.Error("Expected first Swap to return false")
+		}
+
+		// Second swap should return true (already shut down)
+		if !session.isShutdown.Swap(true) {
+			t.Error("Expected second Swap to return true")
+		}
+	})
+
+	t.Run("disconnect clears handlers", func(t *testing.T) {
+		session := &Session{
+			handlers:     make([]sessionHandler, 0),
+			toolHandlers: make(map[string]ToolHandler),
+		}
+
+		var count int
+		session.On(func(event SessionEvent) { count++ })
+
+		// Dispatch before disconnect — handler should fire
+		session.dispatchEvent(SessionEvent{Type: "test"})
+		if count != 1 {
+			t.Fatalf("Expected 1 event before disconnect, got %d", count)
+		}
+
+		// Simulate Disconnect's handler-clearing logic
+		session.handlerMutex.Lock()
+		session.handlers = nil
+		session.handlerMutex.Unlock()
+
+		session.toolHandlersM.Lock()
+		session.toolHandlers = nil
+		session.toolHandlersM.Unlock()
+
+		session.permissionMux.Lock()
+		session.permissionHandler = nil
+		session.permissionMux.Unlock()
+
+		// Dispatch after disconnect — handler should NOT fire
+		session.dispatchEvent(SessionEvent{Type: "test"})
+		if count != 1 {
+			t.Errorf("Expected no additional events after disconnect, got %d total", count)
+		}
+	})
+
+	t.Run("two-phase shutdown then disconnect preserves notification", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var events []string
+		session.On(func(event SessionEvent) {
+			events = append(events, string(event.Type))
+		})
+
+		// Phase 1: Shutdown sends the RPC (simulated) — handlers still active
+		session.isShutdown.Store(true)
+
+		// Server sends back shutdown notification — handler receives it
+		session.dispatchEvent(SessionEvent{Type: "session.shutdown"})
+
+		// Phase 2: Clear handlers (simulating Disconnect)
+		session.handlerMutex.Lock()
+		session.handlers = nil
+		session.handlerMutex.Unlock()
+
+		// Any further events should not reach handlers
+		session.dispatchEvent(SessionEvent{Type: "should.not.arrive"})
+
+		if len(events) != 1 {
+			t.Fatalf("Expected exactly 1 event, got %d: %v", len(events), events)
+		}
+		if events[0] != "session.shutdown" {
+			t.Errorf("Expected session.shutdown, got %s", events[0])
+		}
+	})
+}

nodejs/package-lock.json

@@ -44,7 +44,7 @@
   "author": "GitHub",
   "license": "MIT",
   "dependencies": {
-    "@github/copilot": "^1.0.3-0",
+    "@github/copilot": "^1.0.3",
     "vscode-jsonrpc": "^8.2.1",
     "zod": "^4.3.6"
   },

nodejs/package.json

@@ -299,9 +299,16 @@ describe("Sessions", async () => {
     it("should receive session events", async () => {
         const session = await client.createSession({ onPermissionRequest: approveAll });
         const receivedEvents: Array<{ type: string }> = [];
+        let resolveShutdown: () => void;
+        const shutdownReceived = new Promise<void>((resolve) => {
+            resolveShutdown = resolve;
+        });
 
         session.on((event) => {
             receivedEvents.push(event);
+            if (event.type === "session.shutdown") {
+                resolveShutdown();
+            }
         });
 
         // Send a message and wait for completion
@@ -316,8 +323,15 @@ describe("Sessions", async () => {
         // Verify the assistant response contains the expected answer
         expect(assistantMessage?.data.content).toContain("300");
 
-        // Shut down session (sends RPC without clearing handlers), then destroy
+        // Shut down session and verify shutdown event is received
         await session.shutdown();
+        await Promise.race([
+            shutdownReceived,
+            new Promise((_, reject) =>
+                setTimeout(() => reject(new Error("Timed out waiting for session.shutdown")), 5000)
+            ),
+        ]);
+        expect(receivedEvents.some((e) => e.type === "session.shutdown")).toBe(true);
         await session.destroy();
     });
 

nodejs/test/e2e/session.test.ts

@@ -455,11 +455,14 @@ async def test_should_receive_session_events(self, ctx: E2ETestContext):
         )
         received_events = []
         idle_event = asyncio.Event()
+        shutdown_event = asyncio.Event()
 
         def on_event(event):
             received_events.append(event)
             if event.type.value == "session.idle":
                 idle_event.set()
+            elif event.type.value == "session.shutdown":
+                shutdown_event.set()
 
         session.on(on_event)
 
@@ -483,8 +486,14 @@ def on_event(event):
         assistant_message = await get_final_assistant_message(session)
         assert "300" in assistant_message.data.content
 
-        # Shut down session (sends RPC without clearing handlers), then destroy
+        # Shut down session and verify shutdown event is received
         await session.shutdown()
+        try:
+            await asyncio.wait_for(shutdown_event.wait(), timeout=5)
+        except TimeoutError:
+            pytest.fail("Timed out waiting for session.shutdown")
+        event_types = [e.type.value for e in received_events]
+        assert "session.shutdown" in event_types
         await session.destroy()
 
     async def test_should_create_session_with_custom_config_dir(self, ctx: E2ETestContext):