Hide StreamJsonRpc implementation detail behind IOException

dotnet/README.md

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

dotnet/src/Client.cs

@@ -347,8 +347,8 @@ public async Task<CopilotSession> CreateSessionAsync(SessionConfig? config = nul
             config?.DisabledSkills,
             config?.InfiniteSessions);
 
-        var response = await connection.Rpc.InvokeWithCancellationAsync<CreateSessionResponse>(
-            "session.create", [request], cancellationToken);
+        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 ?? []);
@@ -404,8 +404,8 @@ public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSes
             config?.SkillDirectories,
             config?.DisabledSkills);
 
-        var response = await connection.Rpc.InvokeWithCancellationAsync<ResumeSessionResponse>(
-            "session.resume", [request], cancellationToken);
+        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 ?? []);
@@ -461,8 +461,8 @@ public async Task<PingResponse> PingAsync(string? message = null, CancellationTo
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        return await connection.Rpc.InvokeWithCancellationAsync<PingResponse>(
-            "ping", [new PingRequest { Message = message }], cancellationToken);
+        return await InvokeRpcAsync<PingResponse>(
+            connection.Rpc, "ping", [new PingRequest { Message = message }], cancellationToken);
     }
 
     /// <summary>
@@ -475,8 +475,8 @@ public async Task<GetStatusResponse> GetStatusAsync(CancellationToken cancellati
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        return await connection.Rpc.InvokeWithCancellationAsync<GetStatusResponse>(
-            "status.get", [], cancellationToken);
+        return await InvokeRpcAsync<GetStatusResponse>(
+            connection.Rpc, "status.get", [], cancellationToken);
     }
 
     /// <summary>
@@ -489,8 +489,8 @@ public async Task<GetAuthStatusResponse> GetAuthStatusAsync(CancellationToken ca
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        return await connection.Rpc.InvokeWithCancellationAsync<GetAuthStatusResponse>(
-            "auth.getStatus", [], cancellationToken);
+        return await InvokeRpcAsync<GetAuthStatusResponse>(
+            connection.Rpc, "auth.getStatus", [], cancellationToken);
     }
 
     /// <summary>
@@ -503,8 +503,8 @@ public async Task<List<ModelInfo>> ListModelsAsync(CancellationToken cancellatio
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        var response = await connection.Rpc.InvokeWithCancellationAsync<GetModelsResponse>(
-            "models.list", [], cancellationToken);
+        var response = await InvokeRpcAsync<GetModelsResponse>(
+            connection.Rpc, "models.list", [], cancellationToken);
 
         return response.Models;
     }
@@ -528,8 +528,8 @@ public async Task<List<ModelInfo>> ListModelsAsync(CancellationToken cancellatio
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        var response = await connection.Rpc.InvokeWithCancellationAsync<GetLastSessionIdResponse>(
-            "session.getLastId", [], cancellationToken);
+        var response = await InvokeRpcAsync<GetLastSessionIdResponse>(
+            connection.Rpc, "session.getLastId", [], cancellationToken);
 
         return response.SessionId;
     }
@@ -554,8 +554,8 @@ public async Task DeleteSessionAsync(string sessionId, CancellationToken cancell
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        var response = await connection.Rpc.InvokeWithCancellationAsync<DeleteSessionResponse>(
-            "session.delete", [new DeleteSessionRequest(sessionId)], cancellationToken);
+        var response = await InvokeRpcAsync<DeleteSessionResponse>(
+            connection.Rpc, "session.delete", [new DeleteSessionRequest(sessionId)], cancellationToken);
 
         if (!response.Success)
         {
@@ -584,12 +584,24 @@ public async Task<List<SessionMetadata>> ListSessionsAsync(CancellationToken can
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        var response = await connection.Rpc.InvokeWithCancellationAsync<ListSessionsResponse>(
-            "session.list", [], cancellationToken);
+        var response = await InvokeRpcAsync<ListSessionsResponse>(
+            connection.Rpc, "session.list", [], cancellationToken);
 
         return response.Sessions;
     }
 
+    internal static async Task<T> InvokeRpcAsync<T>(JsonRpc rpc, string method, object?[]? args, CancellationToken cancellationToken)
+    {
+        try
+        {
+            return await rpc.InvokeWithCancellationAsync<T>(method, args, cancellationToken);
+        }
+        catch (StreamJsonRpc.RemoteRpcException ex)
+        {
+            throw new IOException($"Communication error with Copilot CLI: {ex.Message}", ex);
+        }
+    }
+
     private Task<Connection> EnsureConnectedAsync(CancellationToken cancellationToken)
     {
         if (_connectionTask is null && !_options.AutoStart)
@@ -604,8 +616,8 @@ private Task<Connection> EnsureConnectedAsync(CancellationToken cancellationToke
     private async Task VerifyProtocolVersionAsync(Connection connection, CancellationToken cancellationToken)
     {
         var expectedVersion = SdkProtocolVersion.GetVersion();
-        var pingResponse = await connection.Rpc.InvokeWithCancellationAsync<PingResponse>(
-            "ping", [new PingRequest()], cancellationToken);
+        var pingResponse = await InvokeRpcAsync<PingResponse>(
+            connection.Rpc, "ping", [new PingRequest()], cancellationToken);
 
         if (!pingResponse.ProtocolVersion.HasValue)
         {

dotnet/src/Session.cs

@@ -80,6 +80,9 @@ internal CopilotSession(string sessionId, JsonRpc rpc, string? workspacePath = n
         WorkspacePath = workspacePath;
     }
 
+    private Task<T> InvokeRpcAsync<T>(string method, object?[]? args, CancellationToken cancellationToken) =>
+        CopilotClient.InvokeRpcAsync<T>(_rpc, method, args, cancellationToken);
+
     /// <summary>
     /// Sends a message to the Copilot session and waits for the response.
     /// </summary>
@@ -118,7 +121,7 @@ public async Task<string> SendAsync(MessageOptions options, CancellationToken ca
             Mode = options.Mode
         };
 
-        var response = await _rpc.InvokeWithCancellationAsync<SendMessageResponse>(
+        var response = await InvokeRpcAsync<SendMessageResponse>(
             "session.send", [request], cancellationToken);
 
         return response.MessageId;
@@ -351,7 +354,7 @@ internal async Task<PermissionRequestResult> HandlePermissionRequestAsync(JsonEl
     /// </example>
     public async Task<IReadOnlyList<SessionEvent>> GetMessagesAsync(CancellationToken cancellationToken = default)
     {
-        var response = await _rpc.InvokeWithCancellationAsync<GetMessagesResponse>(
+        var response = await InvokeRpcAsync<GetMessagesResponse>(
             "session.getMessages", [new GetMessagesRequest { SessionId = SessionId }], cancellationToken);
 
         return response.Events
@@ -385,7 +388,7 @@ public async Task<IReadOnlyList<SessionEvent>> GetMessagesAsync(CancellationToke
     /// </example>
     public async Task AbortAsync(CancellationToken cancellationToken = default)
     {
-        await _rpc.InvokeWithCancellationAsync<object>(
+        await InvokeRpcAsync<object>(
             "session.abort", [new SessionAbortRequest { SessionId = SessionId }], cancellationToken);
     }
 
@@ -416,8 +419,8 @@ await _rpc.InvokeWithCancellationAsync<object>(
     /// </example>
     public async ValueTask DisposeAsync()
     {
-        await _rpc.InvokeWithCancellationAsync<object>(
-            "session.destroy", [new SessionDestroyRequest() { SessionId = SessionId }]);
+        await InvokeRpcAsync<object>(
+            "session.destroy", [new SessionDestroyRequest() { SessionId = SessionId }], CancellationToken.None);
 
         _eventHandlers.Clear();
         _toolHandlers.Clear();

dotnet/test/SessionTests.cs

@@ -26,7 +26,7 @@ public async Task ShouldCreateAndDestroySessions()
 
         await session.DisposeAsync();
 
-        var ex = await Assert.ThrowsAsync<StreamJsonRpc.RemoteInvocationException>(() => 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<StreamJsonRpc.RemoteInvocationException>(() =>
+        await Assert.ThrowsAsync<IOException>(() =>
             Client.ResumeSessionAsync("non-existent-session-id"));
     }