dotnet: remove DisconnectAsync, keep only DisposeAsync

Address review feedback from SteveSandersonMS: for .NET, the
standard IAsyncDisposable pattern (DisposeAsync) is sufficient
on its own without a duplicate DisconnectAsync method.

Moves the disconnect implementation directly into DisposeAsync
and removes the separate DisconnectAsync method. Updates all
references in Client.cs and README.md accordingly.

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

Author: patniko

dotnet/README.md

@@ -217,22 +217,18 @@ Abort the currently processing message in this session.
 
 Get all events/messages from this session.
 
-##### `DisconnectAsync(CancellationToken cancellationToken = default): Task`
-
-Disconnect the session and release in-memory resources. Session data on disk is preserved — the conversation can be resumed later via `ResumeSessionAsync()`. To permanently delete session data, use `client.DeleteSessionAsync()`.
-
 ##### `DisposeAsync(): ValueTask`
 
-Calls `DisconnectAsync()`. Enables the `await using` pattern for automatic cleanup:
+Close the session and release in-memory resources. Session data on disk is preserved — the conversation can be resumed later via `ResumeSessionAsync()`. To permanently delete session data, use `client.DeleteSessionAsync()`.
 
 ```csharp
 // Preferred: automatic cleanup via await using
 await using var session = await client.CreateSessionAsync(config);
-// session is automatically disconnected when leaving scope
+// session is automatically disposed when leaving scope
 
-// Alternative: explicit disconnect
+// Alternative: explicit dispose
 var session2 = await client.CreateSessionAsync(config);
-await session2.DisconnectAsync();
+await session2.DisposeAsync();
 ```
 
 ---

dotnet/src/Client.cs

@@ -243,11 +243,11 @@ public async Task StopAsync()
         {
             try
             {
-                await session.DisconnectAsync();
+                await session.DisposeAsync();
             }
             catch (Exception ex)
             {
-                errors.Add(new Exception($"Failed to disconnect session {session.SessionId}: {ex.Message}", ex));
+                errors.Add(new Exception($"Failed to dispose session {session.SessionId}: {ex.Message}", ex));
             }
         }
 
@@ -669,7 +669,7 @@ public async Task<List<ModelInfo>> ListModelsAsync(CancellationToken cancellatio
     /// <returns>A task that represents the asynchronous delete operation.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the session does not exist or deletion fails.</exception>
     /// <remarks>
-    /// Unlike <see cref="CopilotSession.DisconnectAsync"/>, which only releases in-memory
+    /// Unlike <see cref="CopilotSession.DisposeAsync"/>, which only releases in-memory
     /// resources and preserves session data for later resumption, this method is
     /// irreversible. The session cannot be resumed after deletion.
     /// </remarks>

dotnet/src/Session.cs

@@ -26,7 +26,7 @@ namespace GitHub.Copilot.SDK;
 /// </para>
 /// <para>
 /// <see cref="CopilotSession"/> implements <see cref="IAsyncDisposable"/>. Use the
-/// <c>await using</c> pattern for automatic cleanup, or call <see cref="DisconnectAsync"/>
+/// <c>await using</c> pattern for automatic cleanup, or call <see cref="DisposeAsync"/>
 /// explicitly. Disposing a session releases in-memory resources but preserves session data
 /// on disk — the conversation can be resumed later via
 /// <see cref="CopilotClient.ResumeSessionAsync"/>. To permanently delete session data,
@@ -530,11 +530,10 @@ public async Task SetModelAsync(string model, CancellationToken cancellationToke
     }
 
     /// <summary>
-    /// Disconnects this session and releases all in-memory resources (event handlers,
+    /// Closes this session and releases all in-memory resources (event handlers,
     /// tool handlers, permission handlers).
     /// </summary>
-    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
-    /// <returns>A task representing the disconnect operation.</returns>
+    /// <returns>A task representing the dispose operation.</returns>
     /// <remarks>
     /// <para>
     /// Session state on disk (conversation history, planning state, artifacts) is
@@ -549,14 +548,16 @@ public async Task SetModelAsync(string model, CancellationToken cancellationToke
     /// </remarks>
     /// <example>
     /// <code>
-    /// // Disconnect when done — session can still be resumed later
-    /// await session.DisconnectAsync();
-    ///
-    /// // Or use 'await using' for automatic disconnection
+    /// // Using 'await using' for automatic disposal — session can still be resumed later
     /// await using var session = await client.CreateSessionAsync(new() { OnPermissionRequest = PermissionHandler.ApproveAll });
+    ///
+    /// // Or manually dispose
+    /// var session2 = await client.CreateSessionAsync(new() { OnPermissionRequest = PermissionHandler.ApproveAll });
+    /// // ... use the session ...
+    /// await session2.DisposeAsync();
     /// </code>
     /// </example>
-    public async Task DisconnectAsync(CancellationToken cancellationToken = default)
+    public async ValueTask DisposeAsync()
     {
         if (Interlocked.Exchange(ref _isDisposed, 1) == 1)
         {
@@ -566,7 +567,7 @@ public async Task DisconnectAsync(CancellationToken cancellationToken = default)
         try
         {
             await InvokeRpcAsync<object>(
-                "session.destroy", [new SessionDestroyRequest() { SessionId = SessionId }], cancellationToken);
+                "session.destroy", [new SessionDestroyRequest() { SessionId = SessionId }], CancellationToken.None);
         }
         catch (ObjectDisposedException)
         {
@@ -583,33 +584,6 @@ await InvokeRpcAsync<object>(
         _permissionHandler = null;
     }
 
-    /// <summary>
-    /// Disposes the <see cref="CopilotSession"/> by disconnecting and releasing all resources.
-    /// </summary>
-    /// <returns>A task representing the dispose operation.</returns>
-    /// <remarks>
-    /// <para>
-    /// This method calls <see cref="DisconnectAsync"/> to perform cleanup. It is the
-    /// implementation of <see cref="IAsyncDisposable"/> and enables the
-    /// <c>await using</c> pattern for automatic resource management.
-    /// </para>
-    /// </remarks>
-    /// <example>
-    /// <code>
-    /// // Using 'await using' for automatic disposal — session can still be resumed later
-    /// await using var session = await client.CreateSessionAsync(new() { OnPermissionRequest = PermissionHandler.ApproveAll });
-    ///
-    /// // Or manually dispose
-    /// var session2 = await client.CreateSessionAsync(new() { OnPermissionRequest = PermissionHandler.ApproveAll });
-    /// // ... use the session ...
-    /// await session2.DisposeAsync();
-    /// </code>
-    /// </example>
-    public async ValueTask DisposeAsync()
-    {
-        await DisconnectAsync();
-    }
-
     internal record SendMessageRequest
     {
         public string SessionId { get; init; } = string.Empty;