Greatly expand E2E test coverage and harden tests across all 4 SDKs

Adds comprehensive end-to-end coverage of the SDK + Copilot CLI surface area
across C#, Python, TypeScript, and Go, with the goal that every public API
and every JSON-RPC method has at least one E2E test. Reorganizes the C#
and Python test layouts to clearly separate unit and E2E tests, and adds
`E2E` suffixes to test class/file names for clarity.

What's added
------------

E2E coverage (parity across all 4 SDKs):
- Session lifecycle: connect/disconnect, dispose semantics, multi-client
  scenarios, resume, force-stop, idle-then-suspend.
- Session config: model selection (vision-enabled/disabled transitions),
  agent selection, allowed/denied tool sets, working directory,
  environment variables, system prompts, MCP servers.
- RPC surface: agent (get/getCurrent/list/reload), session state
  (capabilities/getCurrent/getMetadata/list/reset), trust, model
  (get/getCurrent/list/setCurrent), permission (request/respond/list),
  hooks, plan, telemetry, command execute/elicit/respond.
- Streaming: assistant.message_delta + reasoning_delta ordering and
  matching message IDs across delta and final events.
- Suspend RPC: suspend during pending permission, suspend during pending
  external tool, suspend idle session, resume + continue conversation
  after suspend.
- Hooks: pre/post tool, pre/post session, deny verification (asserts
  target file is unchanged after a deny).
- Permissions: per-session auth tokens with auto-token opt-out for tests
  that explicitly verify the unauthenticated path.
- GitHub references, attachments, custom request headers, trace context
  propagation.
- Tool routing, command handlers, elicitation flow.

Unit coverage:
- Forward-compatibility for unknown discriminators and unknown event
  envelope types so unrecognized future events round-trip safely.

Snapshot harness:
- 100+ new YAML snapshots under `test/snapshots/` covering the new
  scenarios; existing snapshots normalized for portability.

Test layout:
- C# tests split into `dotnet/test/E2E/` and `dotnet/test/Unit/`
  folders; xUnit collection serializes E2E execution to avoid CLI
  process contention (with explanatory comment at the attribute site).
- Python E2E tests live under `python/e2e/` with a shared harness
  proxy/context. `E2E` suffix added to classes/methods.
- Go E2E tests use `_e2e_test.go` suffix and an `E2E` test-function
  suffix for clarity.
- TypeScript E2E tests use `.e2e.test.ts` suffix; `createSdkTestContext`
  registers Vitest hooks that auto-stop `CopilotClient` and `CapiProxy`.

What's fixed
------------

Snapshot drift root cause:
- `test/harness/replayingCapiProxy.ts`: `writeCapturesToDisk` was
  called from both `updateConfig` and `stop` regardless of CI mode.
  When a test exercised only a subset of a multi-conversation snapshot,
  the file was silently rewritten with that subset, breaking later runs.
  Both writes are now guarded by `process.env.GITHUB_ACTIONS !== "true"`.

`gh` CLI environment-dependent help text:
- Added a `normalizeGhAuthMessages` tool result normalizer so the two
  forms of "auth required" help text emitted by `gh` (GitHub Actions
  vs. local dev) both map to a stable `\` placeholder
  before snapshot match.

PerSessionAuth auto-token leak:
- `dotnet/test/Harness/E2ETestContext.cs`: added an
  `autoInjectGitHubToken` parameter so `CreateAuthTestClient` can
  opt out of the CI auto-token injection that was silently authenticating
  tests verifying the unauthenticated path.

Go SDK lifecycle and codegen:
- Polling-based `waitForCapability` helper in `go/session_test.go`
  to replace race-prone fixed sleeps.
- Telemetry marker constant aligned with snapshot.
- Codegen / lifecycle bugs surfaced while porting C# E2E coverage.

TypeScript cleanup hangs:
- Replaced fixed `setTimeout` waits in lifecycle/session tests with
  bounded polling helpers (`waitFor` / `getLastSessionId` /
  `getSessionMetadata` polls).
- Bumped the `should stop cleanly` test timeout to 60s to absorb
  slow-machine variability.

Python:
- `_wait_for` polling helper in `test_commands_and_elicitation.py`
  replaces flaky fixed sleeps.

Verification
------------

Five consecutive full-suite runs across all 4 SDKs, all clean (the final
run was executed with all 4 suites in parallel to confirm the fixes hold
under contention):

- C#:     319 passed / 0 failed / 4 skipped
- Python: 356 passed / 0 failed / 8 skipped
- TS:     328 passed / 0 failed / 9 skipped
- Go:     all packages ok

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

Author: stephentoub

dotnet/src/Client.cs

@@ -1775,6 +1775,7 @@ internal record PermissionRequestResponseV2(
     [JsonSerializable(typeof(GetSessionMetadataResponse))]
     [JsonSerializable(typeof(ModelCapabilitiesOverride))]
     [JsonSerializable(typeof(PermissionRequestResult))]
+    [JsonSerializable(typeof(PermissionRequestResultKind))]
     [JsonSerializable(typeof(PermissionRequestResponseV2))]
     [JsonSerializable(typeof(ProviderConfig))]
     [JsonSerializable(typeof(ResumeSessionRequest))]

dotnet/src/Generated/Rpc.cs

@@ -2787,6 +2787,7 @@ public class SystemMessageTransformRpcResponse
 [JsonSerializable(typeof(ModelSupports))]
 [JsonSerializable(typeof(ModelVisionLimits))]
 [JsonSerializable(typeof(PermissionRequestResult))]
+[JsonSerializable(typeof(PermissionRequestResultKind))]
 [JsonSerializable(typeof(PingRequest))]
 [JsonSerializable(typeof(PingResponse))]
 [JsonSerializable(typeof(ProviderConfig))]

dotnet/src/Types.cs

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+using Xunit;
+
+// Each E2E test class fixture spins up its own Copilot CLI subprocess plus a CapiProxy
+// (replaying HTTP proxy) Node.js subprocess. With ~25 test classes, running them in parallel
+// would launch ~50 long-lived Node.js processes simultaneously and exhaust both file
+// descriptors and memory on developer machines and CI runners (especially Windows). Tests
+// within a class already run serially via xUnit's IClassFixture contract; this attribute
+// extends that to cross-class execution. Re-enable parallelization only after either
+// (a) sharing a single CLI subprocess across classes, or (b) gating concurrency with a
+// semaphore that limits concurrent fixtures to a small number (e.g. 2-3).
+[assembly: CollectionBehavior(DisableTestParallelization = true)]

dotnet/test/AssemblyInfo.cs

@@ -6,9 +6,9 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GitHub.Copilot.SDK.Test;
+namespace GitHub.Copilot.SDK.Test.E2E;
 
-public class AskUserTests(E2ETestFixture fixture, ITestOutputHelper output) : E2ETestBase(fixture, "ask_user", output)
+public class AskUserE2ETests(E2ETestFixture fixture, ITestOutputHelper output) : E2ETestBase(fixture, "ask_user", output)
 {
     [Fact]
     public async Task Should_Invoke_User_Input_Handler_When_Model_Uses_Ask_User_Tool()

dotnet/test/AskUserTests.cs dotnet/test/E2E/AskUserE2ETests.csdotnet/test/AskUserTests.cs renamed to dotnet/test/E2E/AskUserE2ETests.cs

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+using GitHub.Copilot.SDK.Test.Harness;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GitHub.Copilot.SDK.Test.E2E;
+
+/// <summary>
+/// Smoke coverage for the Copilot CLI built-in tools (bash, view, edit, create_file,
+/// grep, glob). Each test asks the model to use one tool and then verifies the model's
+/// final response reflects the tool's result. Mirrors
+/// <c>nodejs/test/e2e/builtin_tools.e2e.test.ts</c>.
+/// </summary>
+public class BuiltinToolsE2ETests(E2ETestFixture fixture, ITestOutputHelper output)
+    : E2ETestBase(fixture, "builtin_tools", output)
+{
+    [Fact]
+    public async Task Should_Capture_Exit_Code_In_Output()
+    {
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Run 'echo hello && echo world'. Tell me the exact output.",
+        });
+        var content = msg?.Data.Content ?? string.Empty;
+        Assert.Contains("hello", content);
+        Assert.Contains("world", content);
+    }
+
+    [Fact]
+    public async Task Should_Capture_Stderr_Output()
+    {
+        // The Copilot CLI runs commands through a shell tool that resolves to bash on
+        // Linux/macOS and PowerShell on Windows. The TS prompt only works on bash, so
+        // skip this test on Windows to mirror the TS `it.skipIf(process.platform === "win32")`.
+        if (OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Run 'echo error_msg >&2; echo ok' and tell me what stderr said. Reply with just the stderr content.",
+        });
+        Assert.Contains("error_msg", msg?.Data.Content ?? string.Empty);
+    }
+
+    [Fact]
+    public async Task Should_Read_File_With_Line_Range()
+    {
+        await File.WriteAllTextAsync(Path.Join(Ctx.WorkDir, "lines.txt"), "line1\nline2\nline3\nline4\nline5\n");
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Read lines 2 through 4 of the file 'lines.txt' in this directory. Tell me what those lines contain.",
+        });
+        var content = msg?.Data.Content ?? string.Empty;
+        Assert.Contains("line2", content);
+        Assert.Contains("line4", content);
+    }
+
+    [Fact]
+    public async Task Should_Handle_Nonexistent_File_Gracefully()
+    {
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Try to read the file 'does_not_exist.txt'. If it doesn't exist, say 'FILE_NOT_FOUND'.",
+        });
+        var content = (msg?.Data.Content ?? string.Empty).ToUpperInvariant();
+        // Match any of the common phrasings for a missing-file response.
+        Assert.True(
+            content.Contains("NOT FOUND")
+            || content.Contains("NOT EXIST")
+            || content.Contains("NO SUCH")
+            || content.Contains("FILE_NOT_FOUND")
+            || content.Contains("DOES NOT EXIST")
+            || content.Contains("ERROR"),
+            $"Expected a 'not found'-style response, got: {msg?.Data.Content}");
+    }
+
+    [Fact]
+    public async Task Should_Edit_A_File_Successfully()
+    {
+        await File.WriteAllTextAsync(Path.Join(Ctx.WorkDir, "edit_me.txt"), "Hello World\nGoodbye World\n");
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Edit the file 'edit_me.txt': replace 'Hello World' with 'Hi Universe'. Then read it back and tell me its contents.",
+        });
+        Assert.Contains("Hi Universe", msg?.Data.Content ?? string.Empty);
+    }
+
+    [Fact]
+    public async Task Should_Create_A_New_File()
+    {
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Create a file called 'new_file.txt' with the content 'Created by test'. Then read it back to confirm.",
+        });
+        Assert.Contains("Created by test", msg?.Data.Content ?? string.Empty);
+    }
+
+    [Fact]
+    public async Task Should_Search_For_Patterns_In_Files()
+    {
+        await File.WriteAllTextAsync(Path.Join(Ctx.WorkDir, "data.txt"), "apple\nbanana\napricot\ncherry\n");
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Search for lines starting with 'ap' in the file 'data.txt'. Tell me which lines matched.",
+        });
+        var content = msg?.Data.Content ?? string.Empty;
+        Assert.Contains("apple", content);
+        Assert.Contains("apricot", content);
+    }
+
+    [Fact]
+    public async Task Should_Find_Files_By_Pattern()
+    {
+        Directory.CreateDirectory(Path.Join(Ctx.WorkDir, "src"));
+        await File.WriteAllTextAsync(Path.Join(Ctx.WorkDir, "src", "index.ts"), "export const index = 1;");
+        await File.WriteAllTextAsync(Path.Join(Ctx.WorkDir, "README.md"), "# Readme");
+
+        var session = await CreateSessionAsync();
+        var msg = await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt = "Find all .ts files in this directory (recursively). List the filenames you found.",
+        });
+        Assert.Contains("index.ts", msg?.Data.Content ?? string.Empty);
+    }
+}

dotnet/test/E2E/BuiltinToolsE2ETests.cs

@@ -4,11 +4,11 @@
 
 using Xunit;
 
-namespace GitHub.Copilot.SDK.Test;
+namespace GitHub.Copilot.SDK.Test.E2E;
 
 // These tests bypass E2ETestBase because they are about how the CLI subprocess is started
 // Other test classes should instead inherit from E2ETestBase
-public class ClientTests
+public class ClientE2ETests
 {
     [Fact]
     public async Task Should_Start_And_Connect_To_Server_Using_Stdio()
@@ -148,93 +148,6 @@ public async Task Should_List_Models_When_Authenticated()
         }
     }
 
-    [Fact]
-    public void Should_Accept_GitHubToken_Option()
-    {
-        var options = new CopilotClientOptions
-        {
-            GitHubToken = "gho_test_token"
-        };
-
-        Assert.Equal("gho_test_token", options.GitHubToken);
-    }
-
-    [Fact]
-    public void Should_Default_UseLoggedInUser_To_Null()
-    {
-        var options = new CopilotClientOptions();
-
-        Assert.Null(options.UseLoggedInUser);
-    }
-
-    [Fact]
-    public void Should_Allow_Explicit_UseLoggedInUser_False()
-    {
-        var options = new CopilotClientOptions
-        {
-            UseLoggedInUser = false
-        };
-
-        Assert.False(options.UseLoggedInUser);
-    }
-
-    [Fact]
-    public void Should_Allow_Explicit_UseLoggedInUser_True_With_GitHubToken()
-    {
-        var options = new CopilotClientOptions
-        {
-            GitHubToken = "gho_test_token",
-            UseLoggedInUser = true
-        };
-
-        Assert.True(options.UseLoggedInUser);
-    }
-
-    [Fact]
-    public void Should_Throw_When_GitHubToken_Used_With_CliUrl()
-    {
-        Assert.Throws<ArgumentException>(() =>
-        {
-            _ = new CopilotClient(new CopilotClientOptions
-            {
-                CliUrl = "localhost:8080",
-                GitHubToken = "gho_test_token"
-            });
-        });
-    }
-
-    [Fact]
-    public void Should_Throw_When_UseLoggedInUser_Used_With_CliUrl()
-    {
-        Assert.Throws<ArgumentException>(() =>
-        {
-            _ = new CopilotClient(new CopilotClientOptions
-            {
-                CliUrl = "localhost:8080",
-                UseLoggedInUser = false
-            });
-        });
-    }
-
-    [Fact]
-    public void Should_Default_SessionIdleTimeoutSeconds_To_Null()
-    {
-        var options = new CopilotClientOptions();
-
-        Assert.Null(options.SessionIdleTimeoutSeconds);
-    }
-
-    [Fact]
-    public void Should_Accept_SessionIdleTimeoutSeconds_Option()
-    {
-        var options = new CopilotClientOptions
-        {
-            SessionIdleTimeoutSeconds = 600
-        };
-
-        Assert.Equal(600, options.SessionIdleTimeoutSeconds);
-    }
-
     [Fact]
     public async Task Should_Not_Throw_When_Disposing_Session_After_Stopping_Client()
     {

dotnet/test/ClientTests.cs dotnet/test/E2E/ClientE2ETests.csdotnet/test/ClientTests.cs renamed to dotnet/test/E2E/ClientE2ETests.cs

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GitHub.Copilot.SDK.Test.E2E;
+
+public class ClientLifecycleE2ETests(E2ETestFixture fixture, ITestOutputHelper output)
+    : E2ETestBase(fixture, "client_lifecycle", output)
+{
+    [Fact]
+    public async Task Should_Receive_Session_Created_Lifecycle_Event()
+    {
+        var created = new TaskCompletionSource<SessionLifecycleEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+        using var subscription = Client.On(evt =>
+        {
+            if (evt.Type == SessionLifecycleEventTypes.Created)
+            {
+                created.TrySetResult(evt);
+            }
+        });
+
+        var session = await CreateSessionAsync();
+        var evt = await created.Task.WaitAsync(TimeSpan.FromSeconds(10));
+
+        Assert.Equal(SessionLifecycleEventTypes.Created, evt.Type);
+        Assert.Equal(session.SessionId, evt.SessionId);
+    }
+
+    [Fact]
+    public async Task Should_Filter_Session_Lifecycle_Events_By_Type()
+    {
+        var created = new TaskCompletionSource<SessionLifecycleEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+        using var subscription = Client.On(SessionLifecycleEventTypes.Created, evt => created.TrySetResult(evt));
+
+        var session = await CreateSessionAsync();
+        var evt = await created.Task.WaitAsync(TimeSpan.FromSeconds(10));
+
+        Assert.Equal(SessionLifecycleEventTypes.Created, evt.Type);
+        Assert.Equal(session.SessionId, evt.SessionId);
+    }
+
+    [Fact]
+    public async Task Disposing_Lifecycle_Subscription_Stops_Receiving_Events()
+    {
+        var count = 0;
+        var created = new TaskCompletionSource<SessionLifecycleEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var subscription = Client.On(_ => Interlocked.Increment(ref count));
+        subscription.Dispose();
+        using var activeSubscription = Client.On(SessionLifecycleEventTypes.Created, evt => created.TrySetResult(evt));
+
+        var session = await CreateSessionAsync();
+        var evt = await created.Task.WaitAsync(TimeSpan.FromSeconds(10));
+
+        Assert.Equal(session.SessionId, evt.SessionId);
+        Assert.Equal(0, Interlocked.CompareExchange(ref count, 0, 0));
+    }
+
+    [Theory]
+    [InlineData(true)]   // async dispose path (DisposeAsync)
+    [InlineData(false)]  // sync dispose path (Dispose)
+    public async Task Dispose_Disconnects_Client_And_Disposes_Rpc_Surface(bool useAsyncDispose)
+    {
+        var client = Ctx.CreateClient();
+        await client.StartAsync();
+
+        Assert.Equal(ConnectionState.Connected, client.State);
+
+        if (useAsyncDispose)
+        {
+            await client.DisposeAsync();
+        }
+        else
+        {
+            client.Dispose();
+        }
+
+        Assert.Equal(ConnectionState.Disconnected, client.State);
+        Assert.Throws<ObjectDisposedException>(() => client.Rpc);
+    }
+}