Isolate reasoning streaming fixtures

Give the Python, Go, and .NET streaming reasoning tests dedicated proxy contexts so cached model catalogs cannot hide gpt-5.4.

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

Copilot-Session: 9b80f6cb-b851-4598-8294-f4431c6f3143

Author: ellismg

dotnet/test/E2E/StreamingFidelityE2ETests.cs

@@ -150,7 +150,10 @@ public async Task Should_Emit_Streaming_Deltas_With_Reasoning_Effort_Configured(
     {
         // Verifies that setting ReasoningEffort alongside Streaming=true does not break
         // the streaming pipeline — deltas still arrive and complete successfully.
-        var session = await CreateSessionAsync(new SessionConfig
+        await using var isolatedCtx = await E2ETestContext.CreateAsync();
+        await isolatedCtx.ConfigureForTestAsync("streaming_fidelity", nameof(Should_Emit_Streaming_Deltas_With_Reasoning_Effort_Configured));
+        var isolatedClient = isolatedCtx.CreateClient();
+        await using var session = await isolatedCtx.CreateSessionAsync(isolatedClient, new SessionConfig
         {
             Model = "gpt-5.4",
             Streaming = true,
@@ -178,8 +181,6 @@ public async Task Should_Emit_Streaming_Deltas_With_Reasoning_Effort_Configured(
         var messages = await session.GetEventsAsync();
         var startEvent = Assert.Single(messages.OfType<SessionStartEvent>());
         Assert.Equal("high", startEvent.Data.ReasoningEffort);
-
-        await session.DisposeAsync();
     }
 
     [Fact]

go/internal/e2e/streaming_fidelity_e2e_test.go

@@ -285,11 +285,14 @@ func TestStreamingFidelityE2E(t *testing.T) {
 	})
 
 	t.Run("should emit streaming deltas with reasoning effort configured", func(t *testing.T) {
-		ctx.ConfigureForTest(t)
+		reasoningCtx := testharness.NewTestContext(t)
+		reasoningCtx.ConfigureForTest(t)
+		reasoningClient := reasoningCtx.NewClient()
+		t.Cleanup(func() { reasoningClient.ForceStop() })
 
 		// Verifies that setting ReasoningEffort alongside Streaming=true does not break
 		// the streaming pipeline — deltas still arrive and complete successfully.
-		session, err := client.CreateSession(t.Context(), &copilot.SessionConfig{
+		session, err := reasoningClient.CreateSession(t.Context(), &copilot.SessionConfig{
 			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
 			Model:               "gpt-5.4",
 			Streaming:           copilot.Bool(true),

python/e2e/test_streaming_fidelity_e2e.py

@@ -155,35 +155,44 @@ async def test_should_not_produce_deltas_after_session_resume_with_streaming_dis
         finally:
             await new_client.force_stop()
 
-    async def test_should_emit_streaming_deltas_with_reasoning_effort_configured(
-        self, ctx: E2ETestContext
-    ):
+    async def test_should_emit_streaming_deltas_with_reasoning_effort_configured(self):
         """Streaming + reasoning_effort produces delta events and session.start shows effort."""
         from copilot.session_events import SessionStartData
 
-        session = await ctx.client.create_session(
-            on_permission_request=PermissionHandler.approve_all,
-            model="gpt-5.4",
-            streaming=True,
-            reasoning_effort="high",
-        )
-
-        events = []
-        session.on(lambda event: events.append(event))
-
+        isolated_ctx = E2ETestContext()
+        await isolated_ctx.setup()
         try:
-            await session.send_and_wait("What is 15 * 17?", timeout=60.0)
-
-            delta_events = [e for e in events if e.type.value == "assistant.message_delta"]
-            assert len(delta_events) >= 1, "Expected delta events with streaming=True"
-
-            assistant_events = [e for e in events if e.type.value == "assistant.message"]
-            assert len(assistant_events) >= 1, "Expected final assistant.message"
+            await isolated_ctx.configure_for_test(
+                "streaming_fidelity",
+                "should_emit_streaming_deltas_with_reasoning_effort_configured",
+            )
+            session = await isolated_ctx.client.create_session(
+                on_permission_request=PermissionHandler.approve_all,
+                model="gpt-5.4",
+                streaming=True,
+                reasoning_effort="high",
+            )
 
-            # Check session.start event (from get_events) has reasoning_effort
-            all_msgs = await session.get_events()
-            start_event = next((e for e in all_msgs if isinstance(e.data, SessionStartData)), None)
-            assert start_event is not None, "Expected session.start event"
-            assert start_event.data.reasoning_effort == "high"
+            events = []
+            session.on(lambda event: events.append(event))
+
+            try:
+                await session.send_and_wait("What is 15 * 17?", timeout=60.0)
+
+                delta_events = [e for e in events if e.type.value == "assistant.message_delta"]
+                assert len(delta_events) >= 1, "Expected delta events with streaming=True"
+
+                assistant_events = [e for e in events if e.type.value == "assistant.message"]
+                assert len(assistant_events) >= 1, "Expected final assistant.message"
+
+                # Check session.start event (from get_events) has reasoning_effort
+                all_msgs = await session.get_events()
+                start_event = next(
+                    (e for e in all_msgs if isinstance(e.data, SessionStartData)), None
+                )
+                assert start_event is not None, "Expected session.start event"
+                assert start_event.data.reasoning_effort == "high"
+            finally:
+                await session.disconnect()
         finally:
-            await session.disconnect()
+            await isolated_ctx.teardown()