Fix E2E tests: remove shutdown event assertions, update cleanup test

The CLI runtime does not currently emit session.shutdown notifications
during the session.destroy flow, so remove E2E assertions that wait for
the event. The shutdown() method and two-phase API remain in place for
when the runtime is updated.

Update the Node.js failed-cleanup test to reflect that shutdown()'s
idempotency guard causes the destroy retry to succeed with local-only
cleanup when the server process is dead.

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

Author: stephentoub

dotnet/test/SessionTests.cs

@@ -247,7 +247,6 @@ 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,10 +255,6 @@ public async Task Should_Receive_Session_Events()
             {
                 idleReceived.TrySetResult(true);
             }
-            else if (evt is SessionShutdownEvent)
-            {
-                shutdownReceived.TrySetResult(true);
-            }
         });
 
         // Send a message to trigger events
@@ -280,10 +275,8 @@ public async Task Should_Receive_Session_Events()
         Assert.NotNull(assistantMessage);
         Assert.Contains("300", assistantMessage!.Data.Content);
 
-        // Shut down session and verify shutdown event is received
+        // Shut down session (sends RPC without clearing handlers), then dispose
         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

@@ -593,7 +593,6 @@ func TestSession(t *testing.T) {
 
 		var receivedEvents []copilot.SessionEvent
 		idle := make(chan bool)
-		shutdown := make(chan bool)
 
 		session.On(func(event copilot.SessionEvent) {
 			receivedEvents = append(receivedEvents, event)
@@ -602,11 +601,6 @@ func TestSession(t *testing.T) {
 				case idle <- true:
 				default:
 				}
-			} else if event.Type == "session.shutdown" {
-				select {
-				case shutdown <- true:
-				default:
-				}
 			}
 		})
 
@@ -661,24 +655,10 @@ func TestSession(t *testing.T) {
 			t.Errorf("Expected assistant message to contain '300', got %v", assistantMessage.Data.Content)
 		}
 
-		// Shut down session and verify shutdown event is received
+		// Shut down session (sends RPC without clearing handlers), then destroy
 		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)
 		}

nodejs/test/e2e/client.test.ts

@@ -43,27 +43,31 @@ describe("Client", () => {
         expect(client.getState()).toBe("disconnected");
     });
 
-    it.skipIf(process.platform === "darwin")("should return errors on failed cleanup", async () => {
-        // Use TCP mode to avoid stdin stream destruction issues
-        // Without this, on macOS there are intermittent test failures
-        // saying "Cannot call write after a stream was destroyed"
-        // because the JSON-RPC logic is still trying to write to stdin after
-        // the process has exited.
-        const client = new CopilotClient({ useStdio: false });
-
-        await client.createSession({ onPermissionRequest: approveAll });
-
-        // Kill the server processto force cleanup to fail
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const cliProcess = (client as any).cliProcess as ChildProcess;
-        expect(cliProcess).toBeDefined();
-        cliProcess.kill("SIGKILL");
-        await new Promise((resolve) => setTimeout(resolve, 100));
-
-        const errors = await client.stop();
-        expect(errors.length).toBeGreaterThan(0);
-        expect(errors[0].message).toContain("Failed to destroy session");
-    });
+    it.skipIf(process.platform === "darwin")(
+        "should handle cleanup when server process is dead",
+        async () => {
+            // Use TCP mode to avoid stdin stream destruction issues
+            // Without this, on macOS there are intermittent test failures
+            // saying "Cannot call write after a stream was destroyed"
+            // because the JSON-RPC logic is still trying to write to stdin after
+            // the process has exited.
+            const client = new CopilotClient({ useStdio: false });
+
+            await client.createSession({ onPermissionRequest: approveAll });
+
+            // Kill the server process to force the first destroy attempt to fail.
+            // The retry succeeds because shutdown() is idempotent (the guard
+            // prevents a second RPC) and local handler cleanup always works.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const cliProcess = (client as any).cliProcess as ChildProcess;
+            expect(cliProcess).toBeDefined();
+            cliProcess.kill("SIGKILL");
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            const errors = await client.stop();
+            expect(errors).toHaveLength(0);
+        }
+    );
 
     it("should forceStop without cleanup", async () => {
         const client = new CopilotClient({});

nodejs/test/e2e/session.test.ts

@@ -299,16 +299,9 @@ 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
@@ -323,15 +316,8 @@ describe("Sessions", async () => {
         // Verify the assistant response contains the expected answer
         expect(assistantMessage?.data.content).toContain("300");
 
-        // Shut down session and verify shutdown event is received
+        // Shut down session (sends RPC without clearing handlers), then destroy
         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();
     });
 

python/e2e/test_session.py

@@ -455,14 +455,11 @@ 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)
 
@@ -486,14 +483,8 @@ def on_event(event):
         assistant_message = await get_final_assistant_message(session)
         assert "300" in assistant_message.data.content
 
-        # Shut down session and verify shutdown event is received
+        # Shut down session (sends RPC without clearing handlers), then destroy
         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):