Expand cross-SDK scenario and RPC E2E coverage

dotnet/src/Client.cs

@@ -463,6 +463,11 @@ async Task<Connection> StartCoreAsync(CancellationToken ct)
                     "CopilotClient.StartAsync protocol verification complete. Elapsed={Elapsed}",
                     startTimestamp);
 
+                if (_options.ExtensionLaunchProvider is not null)
+                {
+                    await connection.Server.RegisterExtensionLaunchProviderAsync(ct);
+                }
+
                 if (_builtinPluginDirectories.Length > 0)
                 {
                     var request = new BuiltinPluginDirectoriesRequest(_builtinPluginDirectories);
@@ -2041,8 +2046,7 @@ await Rpc.SessionFs.SetProviderAsync(
 
     /// <summary>
     /// Builds the client-global RPC handler bag at construction time. Registers
-    /// the LLM inference provider adapter and/or the GitHub telemetry adapter
-    /// depending on which options are configured. The GitHub token dispatcher is
+    /// the configured connection-level adapters. The GitHub token dispatcher is
     /// always registered because providers are configured per session.
     /// </summary>
     private ClientGlobalApiHandlers? BuildClientGlobalApis()
@@ -2051,6 +2055,7 @@ await Rpc.SessionFs.SetProviderAsync(
         var onGitHubTelemetry = _options.OnGitHubTelemetry;
         return new ClientGlobalApiHandlers
         {
+            ExtensionLaunchProvider = _options.ExtensionLaunchProvider,
             LlmInference = handler is null ? null : new LlmInferenceAdapter(handler, () => _serverRpc),
             GitHubTelemetry = onGitHubTelemetry is null ? null : new GitHubTelemetryAdapter(onGitHubTelemetry, _logger),
             GitHubToken = new GitHubTokenAdapter(this),
@@ -2698,6 +2703,10 @@ private async Task<Connection> ConnectToServerAsync(Process? cliProcess, string?
             {
                 ClientGlobalApiRegistration.RegisterClientGlobalApiHandlers(rpc, _clientGlobalApis);
             }
+            if (cliProcess is not null)
+            {
+                RegisterRpcProcessExit(cliProcess, rpc);
+            }
             rpc.StartListening();
             _ = CancelExternalToolsWhenConnectionClosesAsync(rpc);
             LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
@@ -2729,6 +2738,35 @@ private async Task<Connection> ConnectToServerAsync(Process? cliProcess, string?
         }
     }
 
+    private void RegisterRpcProcessExit(Process cliProcess, JsonRpc rpc)
+    {
+        try
+        {
+            cliProcess.EnableRaisingEvents = true;
+            cliProcess.Exited += (_, _) => DisposeRpcAfterProcessExit(rpc);
+            if (cliProcess.HasExited)
+            {
+                DisposeRpcAfterProcessExit(rpc);
+            }
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or ObjectDisposedException)
+        {
+            _logger.LogDebug(ex, "Unable to monitor the Copilot CLI process for transport closure");
+        }
+    }
+
+    private void DisposeRpcAfterProcessExit(JsonRpc rpc)
+    {
+        try
+        {
+            rpc.Dispose(new ConnectionLostException());
+        }
+        catch (Exception ex) when (IsRecoverableConnectionCleanupFailure(ex))
+        {
+            _logger.LogDebug(ex, "Failed to dispose JSON-RPC connection after Copilot CLI process exit");
+        }
+    }
+
     private static bool IsRecoverableConnectionCleanupFailure(Exception exception)
         => exception is not OutOfMemoryException
             and not StackOverflowException

dotnet/src/JsonRpc.cs

@@ -39,10 +39,11 @@
     private readonly ConcurrentDictionary<long, PendingRequest> _pendingRequests = new();
     private readonly ConcurrentDictionary<string, MethodRegistration> _methods = new();
     private readonly TaskCompletionSource _completionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
     private readonly SemaphoreSlim _writeLock = new(1, 1);
     private readonly CancellationTokenSource _disposeCts = new();
     private long _nextId;
-    private bool _disposed;
+    private int _disposeStarted;
+    private Exception? _terminalError;
 
     /// <summary>
     /// Initializes a new <see cref="JsonRpc"/>.
@@ -96,6 +97,11 @@
         CancellationTokenRegistration cancelRegistration = default;
         try
         {
+            if (Volatile.Read(ref _terminalError) is { } terminalError)
+            {
+                throw terminalError;
+            }
+
             if (cancellationToken.CanBeCanceled)
             {
                 cancelRegistration = cancellationToken.Register(static state =>
@@ -136,6 +142,11 @@
             LogInvokeTiming(LogLevel.Debug, ex, method, id, "Canceled", timingTimestamp);
             throw;
         }
+        catch (ObjectDisposedException ex) when (Volatile.Read(ref _terminalError) is ConnectionLostException)
+        {
+            LogInvokeTiming(LogLevel.Warning, ex, method, id, "Failed", timingTimestamp);
+            throw new ConnectionLostException();
+        }
         catch (Exception ex)
         {
             LogInvokeTiming(LogLevel.Warning, ex, method, id, "Failed", timingTimestamp);
@@ -183,27 +194,25 @@
     }
 
     /// <inheritdoc />
-    public void Dispose()
+    public void Dispose() => Dispose(new ObjectDisposedException(nameof(JsonRpc)));
+
+    internal void Dispose(Exception reason)
     {
-        if (_disposed)
+        if (Interlocked.Exchange(ref _disposeStarted, 1) != 0)
         {
             return;
         }
 
-        _disposed = true;
-        _disposeCts.Cancel();
-
-        // Fail all pending requests
-        foreach (var kvp in _pendingRequests)
+        FailPendingRequests(reason);
+        try
         {
-            if (_pendingRequests.TryRemove(kvp.Key, out var pending))
-            {
-                pending.TrySetException(new ObjectDisposedException(nameof(JsonRpc)));
-            }
+            _disposeCts.Cancel();
+        }
+        finally
+        {
+            _completionSource.TrySetResult();
+            _writeLock.Dispose();
         }
-
-        _completionSource.TrySetResult();
-        _writeLock.Dispose();
     }
 
     private async Task SendMessageAsync<T>(T message, JsonTypeInfo<T> typeInfo, CancellationToken cancellationToken)
@@ -338,17 +347,21 @@
         }
         finally
         {
-            // Fail all pending requests
-            foreach (var kvp in _pendingRequests)
+            FailPendingRequests(new ConnectionLostException());
+            _completionSource.TrySetResult();
+        }
+    }
+
+    private void FailPendingRequests(Exception reason)
+    {
+        var terminalError = Interlocked.CompareExchange(ref _terminalError, reason, null) ?? reason;
+        foreach (var kvp in _pendingRequests)
+        {
+            if (_pendingRequests.TryRemove(kvp.Key, out var pending))
             {
-                if (_pendingRequests.TryRemove(kvp.Key, out var pending))
-                {
-                    pending.TrySetException(new ConnectionLostException());
-                }
+                pending.TrySetException(terminalError);
             }
-
-            _completionSource.TrySetResult();
         }
     }
 
     /// <summary>

dotnet/src/Types.cs

@@ -319,6 +319,7 @@ private CopilotClientOptions(CopilotClientOptions? other)
         OnListModels = other.OnListModels;
         SessionFs = other.SessionFs;
         RequestHandler = other.RequestHandler;
+        ExtensionLaunchProvider = other.ExtensionLaunchProvider;
         OnGitHubTelemetry = other.OnGitHubTelemetry;
         SessionIdleTimeoutSeconds = other.SessionIdleTimeoutSeconds;
         EnableRemoteSessions = other.EnableRemoteSessions;
@@ -433,6 +434,14 @@ private CopilotClientOptions(CopilotClientOptions? other)
     [Experimental(Diagnostics.Experimental)]
     public CopilotRequestHandler? RequestHandler { get; set; }
 
+    /// <summary>
+    /// Connection-level extension launch profile provider.
+    /// When set, the SDK registers the provider during <c>StartAsync()</c>
+    /// before any session can be created.
+    /// </summary>
+    [Experimental(Diagnostics.Experimental)]
+    public IExtensionLaunchProviderHandler? ExtensionLaunchProvider { get; set; }
+
     /// <summary>
     /// Experimental. Receives GitHub telemetry events the runtime forwards to this
     /// connection; setting a handler opts created/resumed sessions into forwarding.