Update SDK snapshot for Copilot CLI 1.0.91-0

Author: copilot-cli-release-app[bot]

.github/workflows/sdk-java.yml

@@ -63,8 +63,6 @@ jobs:
         run: ./mvnw javadoc:javadoc
       - if: github.event_name != 'merge_group' && matrix.test-jdk == '25'
         run: ./mvnw spotless:check
-      - run: npm ci --ignore-scripts
-        working-directory: ${{ inputs.sdk-home }}/test/harness
       - if: matrix.test-jdk == '25'
         env:
           CI: "true"

CONTRIBUTING.md

@@ -276,10 +276,13 @@ export COPILOT_CLI_PATH="$(npm --prefix nodejs run --silent prepare:runtime -- -
 export COPILOT_LEGACY_CLI_PATH="$(npm --prefix nodejs run --silent prepare:runtime -- --print-legacy-path)"
 npm --prefix nodejs test -- test/e2e/structured_output.e2e.test.ts
 (cd dotnet && dotnet test test/GitHub.Copilot.SDK.Test.csproj \
+  -p:CopilotSkipCliDownload=true \
   --filter FullyQualifiedName~StructuredOutputE2ETests)
 ```
 
 These are shell-local overrides for focused runs, not machine-wide settings.
+The .NET flag skips MSBuild's separate release download; the tests use the
+prepared runtime from `COPILOT_CLI_PATH`.
 The facade sets runtime paths only for its own child processes and clears
 stale or cross-target overrides before building the host CLI. Cross-target CI
 instead stages explicit artifacts and uses native test commands; do not copy

dotnet/src/Client.cs

@@ -699,7 +699,7 @@ or IOException
 
         if (ctx.FfiHost is { } ffiHost)
         {
-            try { ffiHost.Dispose(); }
+            try { await Task.Run(ffiHost.Dispose).ConfigureAwait(false); }
             catch (Exception ex) { AddCleanupError(errors, ex, _logger); }
             _ffiHost = null;
         }

dotnet/src/Generated/Rpc.cs

@@ -22,6 +22,38 @@ public class McpOAuthE2ETests(E2ETestFixture fixture, ITestOutputHelper output)
     private const string ReauthToken = ExpectedToken + "-reauth";
     private const string CimdUrl = "https://github.com/copilot/cli/client-metadata.json";
 
+    [Fact]
+    public async Task Should_Reclaim_Server_Process_When_Startup_Is_Canceled()
+    {
+        using var process = Process.Start(new ProcessStartInfo("node")
+        {
+            Arguments = "-e \"console.log('started'); setInterval(() => {}, 1000)\"",
+            UseShellExecute = false,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            CreateNoWindow = true,
+        })!;
+        using var observer = Process.GetProcessById(process.Id);
+        using var cancellation = new CancellationTokenSource();
+        try
+        {
+            Assert.Equal("started", await process.StandardOutput.ReadLineAsync().WaitAsync(TimeSpan.FromSeconds(10)));
+            var startup = OAuthMcpServer.WaitForListeningAsync(process, cancellation.Token);
+            cancellation.Cancel();
+
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => startup);
+            Assert.True(observer.HasExited, "Canceled startup retained the OAuth server process.");
+        }
+        finally
+        {
+            if (!observer.HasExited)
+            {
+                observer.Kill(entireProcessTree: true);
+                await observer.WaitForExitAsync();
+            }
+        }
+    }
+
     [Fact]
     public async Task Should_Use_Cimd_Url_Instead_Of_Dynamic_Registration()
     {
@@ -324,23 +356,53 @@ public static async Task<OAuthMcpServer> StartAsync(string expectedToken, bool c
 
             var process = Process.Start(startInfo)
                 ?? throw new InvalidOperationException("Failed to start OAuth MCP server.");
-            var stderrTask = process.StandardError.ReadToEndAsync();
-
             using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-            while (!cts.IsCancellationRequested)
+            return await WaitForListeningAsync(process, cts.Token);
+        }
+
+        public static async Task<OAuthMcpServer> WaitForListeningAsync(Process process, CancellationToken cancellationToken)
+        {
+#if NET
+            var stderrTask = process.StandardError.ReadToEndAsync(CancellationToken.None);
+#else
+            var stderrTask = process.StandardError.ReadToEndAsync();
+#endif
+            try
             {
-                var line = await process.StandardOutput.ReadLineAsync(cts.Token);
-                if (line is null)
+                while (true)
                 {
-                    throw new InvalidOperationException($"OAuth MCP server exited before listening: {await stderrTask}");
+                    var line = await process.StandardOutput.ReadLineAsync(cancellationToken);
+                    if (line is null)
+                    {
+                        throw new InvalidOperationException($"OAuth MCP server exited before listening: {await stderrTask}");
+                    }
+                    if (line.StartsWith("Listening: ", StringComparison.Ordinal))
+                    {
+                        return new OAuthMcpServer(process, line["Listening: ".Length..]);
+                    }
                 }
-                if (line.StartsWith("Listening: ", StringComparison.Ordinal))
+            }
+            catch (Exception startupError)
+            {
+                try
                 {
-                    return new OAuthMcpServer(process, line["Listening: ".Length..]);
+                    if (!process.HasExited)
+                    {
+                        process.Kill(entireProcessTree: true);
+                    }
+                    await process.WaitForExitAsync(CancellationToken.None);
+                    await stderrTask;
+                }
+                catch (Exception cleanupError)
+                {
+                    throw new AggregateException(startupError, cleanupError);
                 }
+                finally
+                {
+                    process.Dispose();
+                }
+                throw;
             }
-
-            throw new TimeoutException($"Timed out waiting for OAuth MCP server: {await stderrTask}");
         }
 
         public async Task<List<OAuthMcpRequest>> GetRequestsAsync()

dotnet/src/Generated/SessionEvents.cs

@@ -20,6 +20,10 @@ public async Task Should_Invoke_PreToolUse_And_PostToolUse_Hooks_For_Sub_Agent_T
     {
         var hookLog = new ConcurrentBag<(string Kind, string ToolName, string SessionId)>();
         var requestHandler = new RecordingForwardingRequestHandler();
+        const string waitingText = "I've launched an explore agent to read subagent-test.txt. Waiting for it to complete...";
+        const string finalText = "The explore agent successfully read the file. The contents of **subagent-test.txt** are:\n\n```\nHello from subagent test!\n```";
+        var parentSessionId = Guid.NewGuid().ToString();
+        var parentWaiting = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
         // Create a client with the session-based subagents feature flag
         var env = new Dictionary<string, string>(Ctx.GetEnvironment());
@@ -32,6 +36,7 @@ public async Task Should_Invoke_PreToolUse_And_PostToolUse_Hooks_For_Sub_Agent_T
 
         var session = await Ctx.CreateSessionAsync(client, new SessionConfig
         {
+            SessionId = parentSessionId,
             OnPermissionRequest = PermissionHandler.ApproveAll,
             Hooks = new SessionHooks
             {
@@ -43,25 +48,52 @@ public async Task Should_Invoke_PreToolUse_And_PostToolUse_Hooks_For_Sub_Agent_T
                         PermissionDecision = "allow"
                     });
                 },
-                OnPostToolUse = (input, invocation) =>
+                OnPostToolUse = async (input, invocation) =>
                 {
                     hookLog.Add(("post", input.ToolName, input.SessionId));
-                    return Task.FromResult<PostToolUseHookOutput?>(null);
+                    // A fast child can inject its result before the fixture's waiting reply is requested.
+                    if (input.ToolName == "view" && input.SessionId != parentSessionId)
+                    {
+                        await parentWaiting.Task;
+                    }
+                    return null;
                 },
             },
         });
 
         // Create a file for the sub-agent to read
         await File.WriteAllTextAsync(Path.Join(Ctx.WorkDir, "subagent-test.txt"), "Hello from subagent test!");
 
-        await session.SendAndWaitAsync(
-            new MessageOptions
+        using var subscription = session.On<AssistantMessageEvent>(message =>
+        {
+            if (string.IsNullOrEmpty(message.AgentId) && message.Data.Content == waitingText)
             {
-                Prompt = "Use the task tool to spawn an explore agent that reads the file "
-                    + "subagent-test.txt in the current directory and reports its contents. "
-                    + "You must use the task tool."
-            },
-            timeout: TimeSpan.FromSeconds(120));
+                parentWaiting.TrySetResult(true);
+            }
+        });
+        try
+        {
+            var response = await session.SendAndWaitAsync(
+                new MessageOptions
+                {
+                    Prompt = "Use the task tool to spawn an explore agent that reads the file "
+                        + "subagent-test.txt in the current directory and reports its contents. "
+                        + "You must use the task tool."
+                },
+                timeout: TimeSpan.FromSeconds(120));
+            Assert.NotNull(response);
+            Assert.True(string.IsNullOrEmpty(response.AgentId));
+            Assert.Equal(finalText, response.Data.Content);
+            var replies = (await session.GetEventsAsync()).OfType<AssistantMessageEvent>()
+                .Where(message => string.IsNullOrEmpty(message.AgentId))
+                .Select(message => message.Data.Content)
+                .Where(content => content == waitingText || content == finalText);
+            Assert.Equal([waitingText, finalText], replies);
+        }
+        finally
+        {
+            parentWaiting.TrySetResult(true);
+        }
 
         var log = hookLog.ToArray();
 

dotnet/test/E2E/McpOAuthE2ETests.cs

@@ -20,7 +20,7 @@ public sealed class E2ETestContext : IAsyncDisposable
 
     public string HomeDir { get; }
     public string WorkDir { get; }
-    public string ProxyUrl { get; }
+    public string ProxyUrl { get; private set; }
     internal static bool UsesInProcessTransport => IsInProcess(null);
 
     /// <summary>Optional logger injected by tests; applied to all clients created via <see cref="CreateClient"/>.</summary>
@@ -47,7 +47,12 @@ private E2ETestContext(string homeDir, string workDir, string proxyUrl, ReplayPr
         _legacyCliPath = GetCachedCliPath(repoRoot, "--print-legacy-path");
     }
 
-    public static async Task<E2ETestContext> CreateAsync()
+    public static Task<E2ETestContext> CreateAsync() => CreateAsync(
+        new ReplayProxy(),
+        Path.Combine(Path.GetTempPath(), $"copilot-test-config-{Guid.NewGuid()}"),
+        Path.Combine(Path.GetTempPath(), $"copilot-test-work-{Guid.NewGuid()}"));
+
+    internal static async Task<E2ETestContext> CreateAsync(ReplayProxy proxy, string homeDir, string workDir)
     {
         // A previous in-process context may have left this process's cwd inside a work
         // directory that has since been deleted. getcwd() then fails, which breaks
@@ -57,33 +62,45 @@ public static async Task<E2ETestContext> CreateAsync()
 
         var repoRoot = FindRepoRoot();
 
-        var homeDir = Path.Combine(Path.GetTempPath(), $"copilot-test-config-{Guid.NewGuid()}");
-        var workDir = Path.Combine(Path.GetTempPath(), $"copilot-test-work-{Guid.NewGuid()}");
-
-        Directory.CreateDirectory(homeDir);
-        Directory.CreateDirectory(workDir);
-
         // Resolve symlinks (e.g., macOS /var -> /private/var) so paths
         // match what spawned subprocesses see when they resolve their cwd.
         homeDir = ResolveSymlinks(homeDir);
         workDir = ResolveSymlinks(workDir);
 
-        var proxy = new ReplayProxy();
-        var proxyUrl = await proxy.StartAsync();
-        // Creating an in-process fixture applies this URL before its first
-        // test-specific configuration is posted, so early runtime requests need
-        // an empty but valid replay state.
-        await proxy.ConfigureAsync(
-            Path.Combine(workDir, "__unconfigured__.yaml"),
-            workDir,
-            "capi");
-        await proxy.SetCopilotUserByTokenAsync(DefaultGitHubToken, new CopilotUserConfig(
-            Login: "e2e-test-user",
-            CopilotPlan: "individual_pro",
-            Endpoints: new CopilotUserEndpoints(Api: proxyUrl, Telemetry: "https://localhost:1/telemetry"),
-            AnalyticsTrackingId: "e2e-test-tracking-id", Id: 12345));
-
-        return new E2ETestContext(homeDir, workDir, proxyUrl, proxy, repoRoot);
+        var context = new E2ETestContext(homeDir, workDir, string.Empty, proxy, repoRoot);
+        try
+        {
+            Directory.CreateDirectory(homeDir);
+            Directory.CreateDirectory(workDir);
+
+            context.ProxyUrl = await proxy.StartAsync();
+            // Creating an in-process fixture applies this URL before its first
+            // test-specific configuration is posted, so early runtime requests need
+            // an empty but valid replay state.
+            await proxy.ConfigureAsync(
+                Path.Combine(workDir, "__unconfigured__.yaml"),
+                workDir,
+                "capi");
+            await proxy.SetCopilotUserByTokenAsync(DefaultGitHubToken, new CopilotUserConfig(
+                Login: "e2e-test-user",
+                CopilotPlan: "individual_pro",
+                Endpoints: new CopilotUserEndpoints(Api: context.ProxyUrl, Telemetry: "https://localhost:1/telemetry"),
+                AnalyticsTrackingId: "e2e-test-tracking-id", Id: 12345));
+
+            return context;
+        }
+        catch (Exception startupError)
+        {
+            try
+            {
+                await context.DisposeAsync();
+            }
+            catch (Exception cleanupError)
+            {
+                throw new AggregateException(startupError, cleanupError);
+            }
+            throw;
+        }
     }
 
     /// <summary>

dotnet/test/E2E/SubagentHooksE2ETests.cs

@@ -30,6 +30,9 @@ internal static RuntimeConnection CreateSharedConnection(bool useInProcessTransp
 
     public async Task DisposeAsync()
     {
-        await Ctx.DisposeAsync();
+        if (Ctx is not null)
+        {
+            await Ctx.DisposeAsync();
+        }
     }
 }

dotnet/test/Harness/E2ETestContext.cs

@@ -139,10 +139,17 @@ public async Task StopAsync(bool skipWritingCache = false)
             catch { /* Best effort */ }
         }
 
-        if (_process is { HasExited: false })
+        try
         {
-            try { _process.Kill(entireProcessTree: true); await _process.WaitForExitAsync(); }
-            catch { /* Ignore */ }
+            if (_process is { HasExited: false })
+            {
+                try { _process.Kill(entireProcessTree: true); await _process.WaitForExitAsync(); }
+                catch { /* Ignore */ }
+            }
+        }
+        catch (InvalidOperationException)
+        {
+            // Process.Start failed before this object was associated with a child.
         }
 
         _process?.Dispose();