Replace CopilotRpcException with IOException and add RPC wrapper methods

Co-authored-by: SteveSandersonMS <1101362+SteveSandersonMS@users.noreply.github.com>

Author: Copilot

dotnet/README.md

@@ -452,9 +452,9 @@ try
     var session = await client.CreateSessionAsync();
     await session.SendAsync(new MessageOptions { Prompt = "Hello" });
 }
-catch (CopilotRpcException ex)
+catch (IOException ex)
 {
-    Console.Error.WriteLine($"RPC Error: {ex.Message}");
+    Console.Error.WriteLine($"Communication Error: {ex.Message}");
 }
 catch (Exception ex)
 {

dotnet/src/Client.cs

@@ -347,16 +347,8 @@ public async Task<CopilotSession> CreateSessionAsync(SessionConfig? config = nul
             config?.DisabledSkills,
             config?.InfiniteSessions);
 
-        CreateSessionResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<CreateSessionResponse>(
-                "session.create", [request], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to create session: {ex.Message}", ex);
-        }
+        var response = await InvokeRpcAsync<CreateSessionResponse>(
+            connection.Rpc, "session.create", [request], cancellationToken);
 
         var session = new CopilotSession(response.SessionId, connection.Rpc, response.WorkspacePath);
         session.RegisterTools(config?.Tools ?? []);
@@ -412,16 +404,8 @@ public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSes
             config?.SkillDirectories,
             config?.DisabledSkills);
 
-        ResumeSessionResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<ResumeSessionResponse>(
-                "session.resume", [request], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to resume session: {ex.Message}", ex);
-        }
+        var response = await InvokeRpcAsync<ResumeSessionResponse>(
+            connection.Rpc, "session.resume", [request], cancellationToken);
 
         var session = new CopilotSession(response.SessionId, connection.Rpc, response.WorkspacePath);
         session.RegisterTools(config?.Tools ?? []);
@@ -477,18 +461,8 @@ public async Task<PingResponse> PingAsync(string? message = null, CancellationTo
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        PingResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<PingResponse>(
-                "ping", [new PingRequest { Message = message }], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to ping server: {ex.Message}", ex);
-        }
-
-        return response;
+        return await InvokeRpcAsync<PingResponse>(
+            connection.Rpc, "ping", [new PingRequest { Message = message }], cancellationToken);
     }
 
     /// <summary>
@@ -501,18 +475,8 @@ public async Task<GetStatusResponse> GetStatusAsync(CancellationToken cancellati
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        GetStatusResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<GetStatusResponse>(
-                "status.get", [], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to get status: {ex.Message}", ex);
-        }
-
-        return response;
+        return await InvokeRpcAsync<GetStatusResponse>(
+            connection.Rpc, "status.get", [], cancellationToken);
     }
 
     /// <summary>
@@ -525,18 +489,8 @@ public async Task<GetAuthStatusResponse> GetAuthStatusAsync(CancellationToken ca
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        GetAuthStatusResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<GetAuthStatusResponse>(
-                "auth.getStatus", [], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to get auth status: {ex.Message}", ex);
-        }
-
-        return response;
+        return await InvokeRpcAsync<GetAuthStatusResponse>(
+            connection.Rpc, "auth.getStatus", [], cancellationToken);
     }
 
     /// <summary>
@@ -549,16 +503,8 @@ public async Task<List<ModelInfo>> ListModelsAsync(CancellationToken cancellatio
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        GetModelsResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<GetModelsResponse>(
-                "models.list", [], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to list models: {ex.Message}", ex);
-        }
+        var response = await InvokeRpcAsync<GetModelsResponse>(
+            connection.Rpc, "models.list", [], cancellationToken);
 
         return response.Models;
     }
@@ -582,16 +528,8 @@ public async Task<List<ModelInfo>> ListModelsAsync(CancellationToken cancellatio
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        GetLastSessionIdResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<GetLastSessionIdResponse>(
-                "session.getLastId", [], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to get last session ID: {ex.Message}", ex);
-        }
+        var response = await InvokeRpcAsync<GetLastSessionIdResponse>(
+            connection.Rpc, "session.getLastId", [], cancellationToken);
 
         return response.SessionId;
     }
@@ -616,16 +554,8 @@ public async Task DeleteSessionAsync(string sessionId, CancellationToken cancell
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        DeleteSessionResponse response;
-        try
-        {
-            response = await connection.Rpc.InvokeWithCancellationAsync<DeleteSessionResponse>(
-                "session.delete", [new DeleteSessionRequest(sessionId)], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to delete session: {ex.Message}", ex);
-        }
+        var response = await InvokeRpcAsync<DeleteSessionResponse>(
+            connection.Rpc, "session.delete", [new DeleteSessionRequest(sessionId)], cancellationToken);
 
         if (!response.Success)
         {
@@ -654,18 +584,22 @@ public async Task<List<SessionMetadata>> ListSessionsAsync(CancellationToken can
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        ListSessionsResponse response;
+        var response = await InvokeRpcAsync<ListSessionsResponse>(
+            connection.Rpc, "session.list", [], cancellationToken);
+
+        return response.Sessions;
+    }
+
+    private static async Task<T> InvokeRpcAsync<T>(JsonRpc rpc, string method, object?[]? args, CancellationToken cancellationToken)
+    {
         try
         {
-            response = await connection.Rpc.InvokeWithCancellationAsync<ListSessionsResponse>(
-                "session.list", [], cancellationToken);
+            return await rpc.InvokeWithCancellationAsync<T>(method, args, cancellationToken);
         }
         catch (StreamJsonRpc.RemoteInvocationException ex)
         {
-            throw new CopilotRpcException($"Failed to list sessions: {ex.Message}", ex);
+            throw new IOException($"Communication error with Copilot CLI: {ex.Message}", ex);
         }
-
-        return response.Sessions;
     }
 
     private Task<Connection> EnsureConnectedAsync(CancellationToken cancellationToken)
@@ -682,16 +616,8 @@ private Task<Connection> EnsureConnectedAsync(CancellationToken cancellationToke
     private async Task VerifyProtocolVersionAsync(Connection connection, CancellationToken cancellationToken)
     {
         var expectedVersion = SdkProtocolVersion.GetVersion();
-        PingResponse pingResponse;
-        try
-        {
-            pingResponse = await connection.Rpc.InvokeWithCancellationAsync<PingResponse>(
-                "ping", [new PingRequest()], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to verify protocol version: {ex.Message}", ex);
-        }
+        var pingResponse = await InvokeRpcAsync<PingResponse>(
+            connection.Rpc, "ping", [new PingRequest()], cancellationToken);
 
         if (!pingResponse.ProtocolVersion.HasValue)
         {

dotnet/src/Session.cs

@@ -80,6 +80,18 @@ internal CopilotSession(string sessionId, JsonRpc rpc, string? workspacePath = n
         WorkspacePath = workspacePath;
     }
 
+    private async Task<T> InvokeRpcAsync<T>(string method, object?[]? args, CancellationToken cancellationToken)
+    {
+        try
+        {
+            return await _rpc.InvokeWithCancellationAsync<T>(method, args, cancellationToken);
+        }
+        catch (StreamJsonRpc.RemoteInvocationException ex)
+        {
+            throw new IOException($"Communication error with Copilot CLI: {ex.Message}", ex);
+        }
+    }
+
     /// <summary>
     /// Sends a message to the Copilot session and waits for the response.
     /// </summary>
@@ -118,16 +130,8 @@ public async Task<string> SendAsync(MessageOptions options, CancellationToken ca
             Mode = options.Mode
         };
 
-        SendMessageResponse response;
-        try
-        {
-            response = await _rpc.InvokeWithCancellationAsync<SendMessageResponse>(
-                "session.send", [request], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to send message: {ex.Message}", ex);
-        }
+        var response = await InvokeRpcAsync<SendMessageResponse>(
+            "session.send", [request], cancellationToken);
 
         return response.MessageId;
     }
@@ -359,16 +363,8 @@ internal async Task<PermissionRequestResult> HandlePermissionRequestAsync(JsonEl
     /// </example>
     public async Task<IReadOnlyList<SessionEvent>> GetMessagesAsync(CancellationToken cancellationToken = default)
     {
-        GetMessagesResponse response;
-        try
-        {
-            response = await _rpc.InvokeWithCancellationAsync<GetMessagesResponse>(
-                "session.getMessages", [new GetMessagesRequest { SessionId = SessionId }], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to get messages: {ex.Message}", ex);
-        }
+        var response = await InvokeRpcAsync<GetMessagesResponse>(
+            "session.getMessages", [new GetMessagesRequest { SessionId = SessionId }], cancellationToken);
 
         return response.Events
             .Select(e => SessionEvent.FromJson(e.ToJsonString()))
@@ -401,15 +397,8 @@ public async Task<IReadOnlyList<SessionEvent>> GetMessagesAsync(CancellationToke
     /// </example>
     public async Task AbortAsync(CancellationToken cancellationToken = default)
     {
-        try
-        {
-            await _rpc.InvokeWithCancellationAsync<object>(
-                "session.abort", [new SessionAbortRequest { SessionId = SessionId }], cancellationToken);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to abort session: {ex.Message}", ex);
-        }
+        await InvokeRpcAsync<object>(
+            "session.abort", [new SessionAbortRequest { SessionId = SessionId }], cancellationToken);
     }
 
     /// <summary>
@@ -439,15 +428,8 @@ await _rpc.InvokeWithCancellationAsync<object>(
     /// </example>
     public async ValueTask DisposeAsync()
     {
-        try
-        {
-            await _rpc.InvokeWithCancellationAsync<object>(
-                "session.destroy", [new SessionDestroyRequest() { SessionId = SessionId }]);
-        }
-        catch (StreamJsonRpc.RemoteInvocationException ex)
-        {
-            throw new CopilotRpcException($"Failed to destroy session: {ex.Message}", ex);
-        }
+        await InvokeRpcAsync<object>(
+            "session.destroy", [new SessionDestroyRequest() { SessionId = SessionId }], CancellationToken.None);
 
         _eventHandlers.Clear();
         _toolHandlers.Clear();

dotnet/src/Types.cs

@@ -10,29 +10,6 @@
 
 namespace GitHub.Copilot.SDK;
 
-/// <summary>
-/// Exception thrown when a communication error occurs with the Copilot CLI.
-/// </summary>
-public class CopilotRpcException : IOException
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="CopilotRpcException"/> class.
-    /// </summary>
-    /// <param name="message">The error message that explains the reason for the exception.</param>
-    public CopilotRpcException(string message) : base(message)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="CopilotRpcException"/> class.
-    /// </summary>
-    /// <param name="message">The error message that explains the reason for the exception.</param>
-    /// <param name="innerException">The exception that is the cause of the current exception.</param>
-    public CopilotRpcException(string message, Exception innerException) : base(message, innerException)
-    {
-    }
-}
-
 [JsonConverter(typeof(JsonStringEnumConverter<SystemMessageMode>))]
 public enum ConnectionState
 {

dotnet/test/SessionTests.cs

@@ -26,7 +26,7 @@ public async Task ShouldCreateAndDestroySessions()
 
         await session.DisposeAsync();
 
-        var ex = await Assert.ThrowsAsync<CopilotRpcException>(() => session.GetMessagesAsync());
+        var ex = await Assert.ThrowsAsync<IOException>(() => session.GetMessagesAsync());
         Assert.Contains("not found", ex.Message, StringComparison.OrdinalIgnoreCase);
     }
 
@@ -192,7 +192,7 @@ public async Task Should_Resume_A_Session_Using_A_New_Client()
     [Fact]
     public async Task Should_Throw_Error_When_Resuming_Non_Existent_Session()
     {
-        await Assert.ThrowsAsync<CopilotRpcException>(() =>
+        await Assert.ThrowsAsync<IOException>(() =>
             Client.ResumeSessionAsync("non-existent-session-id"));
     }