Fix E2E CI for @github/copilot 1.0.61

1.0.61 marks several session MCP lifecycle RPC methods as internal
(startServer, restartServer, registerExternalClient,
unregisterExternalClient, reloadWithConfig, configureGitHub,
mcp.oauth.respond). Remove the E2E cases that exercised those methods on
the public client surface across the Node, Python, Go, and .NET MCP
lifecycle suites; the public list-tools/status/stop cases are retained.

Also make the abort-streaming snapshot tolerant of a transport timing
change. Routing fetch through Rust reqwest in the runtime can land the
abort before the in-flight assistant turn is finalized, so the recovery
request's history omits the aborted assistant message. Add a second
conversation covering that dropped-turn path so the replay proxy matches
regardless of which side of the race wins.

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

Author: stephentoub

dotnet/test/E2E/RpcMcpLifecycleE2ETests.cs

@@ -9,9 +9,8 @@
 namespace GitHub.Copilot.Test.E2E;
 
 /// <summary>
-/// E2E coverage for the session-scoped MCP lifecycle RPC methods that were previously untested:
-/// listTools, isServerRunning, stopServer, startServer, restartServer, registerExternalClient,
-/// unregisterExternalClient, reloadWithConfig, configureGitHub, and oauth.respond.
+/// E2E coverage for the public session-scoped MCP lifecycle RPC methods:
+/// listTools, isServerRunning, and stopServer.
 /// </summary>
 public class RpcMcpLifecycleE2ETests(E2ETestFixture fixture, ITestOutputHelper output)
     : E2ETestBase(fixture, "rpc_mcp_lifecycle", output)
@@ -71,121 +70,6 @@ public async Task Should_Stop_Running_Mcp_Server()
         await WaitForMcpRunningAsync(session, serverName, expectedRunning: false);
     }
 
-    [Fact]
-    public async Task Should_Start_And_Restart_Mcp_Server()
-    {
-        const string hostServer = "rpc-lifecycle-host-server";
-        await using var session = await CreateSessionAsync(new SessionConfig
-        {
-            McpServers = CreateTestMcpServers(hostServer),
-        });
-        await WaitForMcpServerStatusAsync(session, hostServer, McpServerStatus.Connected);
-
-        // Start a brand-new server through the lifecycle API, reusing the exact stdio config shape
-        // the bulk session-config path uses so the runtime accepts and connects it.
-        const string startedServer = "rpc-lifecycle-started-server";
-        var config = CreateTestMcpServers(startedServer)[startedServer];
-
-        await session.Rpc.Mcp.StartServerAsync(startedServer, config);
-        await WaitForMcpRunningAsync(session, startedServer, expectedRunning: true);
-
-        // The freshly started server exposes its tools just like a config-provided server.
-        var tools = await session.Rpc.Mcp.ListToolsAsync(startedServer);
-        Assert.NotEmpty(tools.Tools);
-
-        // Restart stops then starts the same server; it must end up running again.
-        await session.Rpc.Mcp.RestartServerAsync(startedServer, config);
-        await WaitForMcpRunningAsync(session, startedServer, expectedRunning: true);
-    }
-
-    [Fact]
-    public async Task Should_Register_And_Unregister_External_Mcp_Client()
-    {
-        const string hostServer = "rpc-lifecycle-extclient-host";
-        await using var session = await CreateSessionAsync(new SessionConfig
-        {
-            McpServers = CreateTestMcpServers(hostServer),
-        });
-        await WaitForMcpServerStatusAsync(session, hostServer, McpServerStatus.Connected);
-
-        const string externalName = "rpc-lifecycle-external-client";
-        Assert.False((await session.Rpc.Mcp.IsServerRunningAsync(externalName)).Running);
-
-        // The runtime stores the supplied client/transport handles on the host registry, so the
-        // registered name immediately reports as running until it is unregistered again.
-        await session.Rpc.Mcp.RegisterExternalClientAsync(
-            externalName,
-            client: new Dictionary<string, object> { ["id"] = externalName },
-            transport: new Dictionary<string, object> { ["kind"] = "in-process" },
-            config: new Dictionary<string, object> { ["command"] = "noop" });
-        Assert.True((await session.Rpc.Mcp.IsServerRunningAsync(externalName)).Running);
-
-        await session.Rpc.Mcp.UnregisterExternalClientAsync(externalName);
-        Assert.False((await session.Rpc.Mcp.IsServerRunningAsync(externalName)).Running);
-    }
-
-    [Fact]
-    public async Task Should_Reload_Mcp_Servers_With_Config()
-    {
-        const string hostServer = "rpc-lifecycle-reload-host";
-        await using var session = await CreateSessionAsync(new SessionConfig
-        {
-            McpServers = CreateTestMcpServers(hostServer),
-        });
-        await WaitForMcpServerStatusAsync(session, hostServer, McpServerStatus.Connected);
-
-        // reloadWithConfig drives the runtime's reloadMcpServers with an explicit host config and
-        // returns the startup filtering result. Reloading an empty server set is a valid no-op.
-        var result = await session.Rpc.Mcp.ReloadWithConfigAsync(new Dictionary<string, object>
-        {
-            ["mcpServers"] = new Dictionary<string, object>(),
-            ["disabledServers"] = new List<string>(),
-        });
-
-        Assert.NotNull(result);
-        Assert.NotNull(result.FilteredServers);
-        Assert.Empty(result.FilteredServers);
-    }
-
-    [Fact]
-    public async Task Should_Configure_GitHub_Mcp_Server()
-    {
-        const string hostServer = "rpc-lifecycle-configure-host";
-        await using var session = await CreateSessionAsync(new SessionConfig
-        {
-            McpServers = CreateTestMcpServers(hostServer),
-        });
-        await WaitForMcpServerStatusAsync(session, hostServer, McpServerStatus.Connected);
-
-        // configureGitHub forwards a typed auth-info union to the runtime. An "api-key" auth info is
-        // a recognized type that the runtime declines to act on, so configuration is left unchanged
-        // (changed=false) while still proving the method is wired through to the handler.
-        var result = await session.Rpc.Mcp.ConfigureGitHubAsync(new Dictionary<string, object?>
-        {
-            ["type"] = "api-key",
-        });
-
-        Assert.NotNull(result);
-        Assert.False(result.Changed);
-    }
-
-    [Fact]
-    public async Task Should_Respond_To_Mcp_Oauth_Request_Without_Pending_Request()
-    {
-        const string hostServer = "rpc-lifecycle-oauth-host";
-        await using var session = await CreateSessionAsync(new SessionConfig
-        {
-            McpServers = CreateTestMcpServers(hostServer),
-        });
-        await WaitForMcpServerStatusAsync(session, hostServer, McpServerStatus.Connected);
-
-        // With no pending OAuth request, the runtime's respondToMcpOAuth is a tolerant no-op: it
-        // looks up the request id, finds nothing, and returns an empty result without throwing. The
-        // call must reach the runtime and complete successfully, proving the method is wired.
-        var result = await session.Rpc.Mcp.Oauth.RespondAsync($"missing-{Guid.NewGuid():N}");
-        Assert.NotNull(result);
-    }
-
     private static Task WaitForMcpRunningAsync(CopilotSession session, string serverName, bool expectedRunning) =>
         Harness.TestHelper.WaitForConditionAsync(
             async () => (await session.Rpc.Mcp.IsServerRunningAsync(serverName)).Running == expectedRunning,

go/internal/e2e/rpc_mcp_lifecycle_e2e_test.go

@@ -80,126 +80,6 @@ func TestRpcMcpLifecycle(t *testing.T) {
 		}
 		waitForPortedMCPRunning(t, session, serverName, false)
 	})
-
-	t.Run("should_start_and_restart_mcp_server", func(t *testing.T) {
-		ctx.ConfigureForTest(t)
-		const hostServer = "rpc-lifecycle-host-server"
-		session := createPortedSession(t, client, &copilot.SessionConfig{MCPServers: testMCPServers(t, hostServer)})
-		defer session.Disconnect()
-		waitForPortedMCPServerStatus(t, session, hostServer, rpc.MCPServerStatusConnected)
-
-		const startedServer = "rpc-lifecycle-started-server"
-		config := testMCPServers(t, startedServer)[startedServer]
-		if _, err := session.RPC.MCP.StartServer(t.Context(), &rpc.MCPStartServerRequest{ServerName: startedServer, Config: config}); err != nil {
-			t.Fatalf("MCP.StartServer failed: %v", err)
-		}
-		waitForPortedMCPRunning(t, session, startedServer, true)
-
-		tools, err := session.RPC.MCP.ListTools(t.Context(), &rpc.MCPListToolsRequest{ServerName: startedServer})
-		if err != nil {
-			t.Fatalf("MCP.ListTools(started) failed: %v", err)
-		}
-		if len(tools.Tools) == 0 {
-			t.Fatal("Expected started MCP server to expose tools")
-		}
-
-		if _, err := session.RPC.MCP.RestartServer(t.Context(), &rpc.MCPRestartServerRequest{ServerName: startedServer, Config: config}); err != nil {
-			t.Fatalf("MCP.RestartServer failed: %v", err)
-		}
-		waitForPortedMCPRunning(t, session, startedServer, true)
-	})
-
-	t.Run("should_register_and_unregister_external_mcp_client", func(t *testing.T) {
-		ctx.ConfigureForTest(t)
-		const hostServer = "rpc-lifecycle-extclient-host"
-		session := createPortedSession(t, client, &copilot.SessionConfig{MCPServers: testMCPServers(t, hostServer)})
-		defer session.Disconnect()
-		waitForPortedMCPServerStatus(t, session, hostServer, rpc.MCPServerStatusConnected)
-
-		const externalName = "rpc-lifecycle-external-client"
-		initial, err := session.RPC.MCP.IsServerRunning(t.Context(), &rpc.MCPIsServerRunningRequest{ServerName: externalName})
-		if err != nil {
-			t.Fatalf("MCP.IsServerRunning(initial external) failed: %v", err)
-		}
-		if initial.Running {
-			t.Fatal("Expected external client to start as not running")
-		}
-
-		if _, err := session.RPC.MCP.RegisterExternalClient(t.Context(), &rpc.MCPRegisterExternalClientRequest{
-			ServerName: externalName,
-			Client:     map[string]any{"id": externalName},
-			Transport:  map[string]any{"kind": "in-process"},
-			Config:     map[string]any{"command": "noop"},
-		}); err != nil {
-			t.Fatalf("MCP.RegisterExternalClient failed: %v", err)
-		}
-		waitForPortedMCPRunning(t, session, externalName, true)
-
-		if _, err := session.RPC.MCP.UnregisterExternalClient(t.Context(), &rpc.MCPUnregisterExternalClientRequest{ServerName: externalName}); err != nil {
-			t.Fatalf("MCP.UnregisterExternalClient failed: %v", err)
-		}
-		waitForPortedMCPRunning(t, session, externalName, false)
-	})
-
-	t.Run("should_reload_mcp_servers_with_config", func(t *testing.T) {
-		ctx.ConfigureForTest(t)
-		const hostServer = "rpc-lifecycle-reload-host"
-		session := createPortedSession(t, client, &copilot.SessionConfig{MCPServers: testMCPServers(t, hostServer)})
-		defer session.Disconnect()
-		waitForPortedMCPServerStatus(t, session, hostServer, rpc.MCPServerStatusConnected)
-
-		result, err := session.RPC.MCP.ReloadWithConfig(t.Context(), &rpc.MCPReloadWithConfigRequest{Config: map[string]any{
-			"mcpServers":      map[string]any{},
-			"disabledServers": []string{},
-		}})
-		if err != nil {
-			t.Fatalf("MCP.ReloadWithConfig failed: %v", err)
-		}
-		if result == nil {
-			t.Fatal("Expected non-nil reload result")
-		}
-		if result.FilteredServers == nil {
-			t.Fatal("Expected non-nil FilteredServers")
-		}
-		if len(result.FilteredServers) != 0 {
-			t.Fatalf("Expected no filtered servers, got %+v", result.FilteredServers)
-		}
-	})
-
-	t.Run("should_configure_github_mcp_server", func(t *testing.T) {
-		ctx.ConfigureForTest(t)
-		const hostServer = "rpc-lifecycle-configure-host"
-		session := createPortedSession(t, client, &copilot.SessionConfig{MCPServers: testMCPServers(t, hostServer)})
-		defer session.Disconnect()
-		waitForPortedMCPServerStatus(t, session, hostServer, rpc.MCPServerStatusConnected)
-
-		result, err := session.RPC.MCP.ConfigureGitHub(t.Context(), &rpc.MCPConfigureGitHubRequest{AuthInfo: map[string]any{"type": "api-key"}})
-		if err != nil {
-			t.Fatalf("MCP.ConfigureGitHub failed: %v", err)
-		}
-		if result == nil {
-			t.Fatal("Expected non-nil configure result")
-		}
-		if result.Changed {
-			t.Fatal("Expected Changed=false")
-		}
-	})
-
-	t.Run("should_respond_to_mcp_oauth_request_without_pending_request", func(t *testing.T) {
-		ctx.ConfigureForTest(t)
-		const hostServer = "rpc-lifecycle-oauth-host"
-		session := createPortedSession(t, client, &copilot.SessionConfig{MCPServers: testMCPServers(t, hostServer)})
-		defer session.Disconnect()
-		waitForPortedMCPServerStatus(t, session, hostServer, rpc.MCPServerStatusConnected)
-
-		result, err := session.RPC.MCP.Oauth().Respond(t.Context(), &rpc.MCPOauthRespondRequest{RequestID: "missing-" + randomHex(t)})
-		if err != nil {
-			t.Fatalf("MCP.Oauth.Respond failed: %v", err)
-		}
-		if result == nil {
-			t.Fatal("Expected non-nil OAuth respond result")
-		}
-	})
 }
 
 func waitForPortedMCPServerStatus(t *testing.T, session *copilot.Session, serverName string, expectedStatus rpc.MCPServerStatus) {

nodejs/test/e2e/rpc_mcp_lifecycle.e2e.test.ts

@@ -148,115 +148,4 @@ describe("Session-scoped MCP lifecycle RPC", async () => {
             await session.disconnect();
         }
     });
-
-    it("should start and restart mcp server", { timeout: 180_000 }, async () => {
-        const hostServer = "rpc-lifecycle-host-server";
-        const session = await createSessionWithMcp(hostServer);
-        try {
-            await waitForMcpServerStatus(session, hostServer);
-
-            const startedServer = "rpc-lifecycle-started-server";
-            const config = createTestMcpServers(startedServer)[startedServer] as unknown as Record<
-                string,
-                unknown
-            >;
-
-            await session.rpc.mcp.startServer({ serverName: startedServer, config });
-            await waitForMcpRunning(session, startedServer, true);
-
-            const tools = await session.rpc.mcp.listTools({ serverName: startedServer });
-            expect(tools.tools.length).toBeGreaterThan(0);
-
-            await session.rpc.mcp.restartServer({ serverName: startedServer, config });
-            await waitForMcpRunning(session, startedServer, true);
-        } finally {
-            await session.disconnect();
-        }
-    });
-
-    it("should register and unregister external mcp client", { timeout: 120_000 }, async () => {
-        const hostServer = "rpc-lifecycle-extclient-host";
-        const session = await createSessionWithMcp(hostServer);
-        try {
-            await waitForMcpServerStatus(session, hostServer);
-
-            const externalName = "rpc-lifecycle-external-client";
-            expect(
-                (await session.rpc.mcp.isServerRunning({ serverName: externalName })).running
-            ).toBe(false);
-
-            await session.rpc.mcp.registerExternalClient({
-                serverName: externalName,
-                client: { id: externalName },
-                transport: { kind: "in-process" },
-                config: { command: "noop" },
-            });
-            expect(
-                (await session.rpc.mcp.isServerRunning({ serverName: externalName })).running
-            ).toBe(true);
-
-            await session.rpc.mcp.unregisterExternalClient({ serverName: externalName });
-            expect(
-                (await session.rpc.mcp.isServerRunning({ serverName: externalName })).running
-            ).toBe(false);
-        } finally {
-            await session.disconnect();
-        }
-    });
-
-    it("should reload mcp servers with config", { timeout: 120_000 }, async () => {
-        const hostServer = "rpc-lifecycle-reload-host";
-        const session = await createSessionWithMcp(hostServer);
-        try {
-            await waitForMcpServerStatus(session, hostServer);
-
-            const result = await session.rpc.mcp.reloadWithConfig({
-                config: {
-                    mcpServers: {},
-                    disabledServers: [],
-                },
-            });
-
-            expect(result).toBeDefined();
-            expect(result.filteredServers).toEqual([]);
-        } finally {
-            await session.disconnect();
-        }
-    });
-
-    it("should configure github mcp server", { timeout: 120_000 }, async () => {
-        const hostServer = "rpc-lifecycle-configure-host";
-        const session = await createSessionWithMcp(hostServer);
-        try {
-            await waitForMcpServerStatus(session, hostServer);
-
-            const result = await session.rpc.mcp.configureGitHub({
-                authInfo: { type: "api-key" },
-            });
-
-            expect(result).toBeDefined();
-            expect(result.changed).toBe(false);
-        } finally {
-            await session.disconnect();
-        }
-    });
-
-    it(
-        "should respond to mcp oauth request without pending request",
-        { timeout: 120_000 },
-        async () => {
-            const hostServer = "rpc-lifecycle-oauth-host";
-            const session = await createSessionWithMcp(hostServer);
-            try {
-                await waitForMcpServerStatus(session, hostServer);
-
-                const result = await session.rpc.mcp.oauth.respond({
-                    requestId: missingName("missing"),
-                });
-                expect(result).toBeDefined();
-            } finally {
-                await session.disconnect();
-            }
-        }
-    );
 });