fix(dotnet): preserve legacy idle fallback

Author: hydraxman

dotnet/src/Session.cs

@@ -443,6 +443,16 @@ async Task MonitorRuntimeCompletionAsync(CancellationToken waitCancellationToken
                 // existing event-only behavior and let session.idle or the timeout win.
                 LogRuntimeCompletionFallbackUnavailable(ex, SessionId);
             }
+            catch (IOException ex) when (ex.InnerException is RemoteRpcException
+            {
+                ErrorCode: RemoteRpcException.MethodNotFoundErrorCode
+            })
+            {
+                // Generated RPC methods surface remote errors through CopilotClient,
+                // which wraps them in IOException. Treat an older runtime's missing
+                // fallback methods the same as a direct method-not-found response.
+                LogRuntimeCompletionFallbackUnavailable(ex, SessionId);
+            }
             catch (OperationCanceledException) when (waitCancellationToken.IsCancellationRequested)
             {
                 // The timeout/caller-cancellation registration completes tcs.

dotnet/test/E2E/SendAndWaitReliabilityE2ETests.cs

@@ -435,6 +435,26 @@ public async Task SendAndWaitAsync_Completes_When_SessionIdle_Notification_Is_Dr
         Assert.Contains(server.Requests, request => request.Method == "session.metadata.activity");
     }
 
+    [Fact]
+    public async Task SendAndWaitAsync_Preserves_Event_Completion_When_Legacy_Runtime_Lacks_Fallback_Rpcs()
+    {
+        await using var server = await FakeCopilotServer.StartAsync();
+        server.ConfigureLegacyRuntimeCompletion();
+        await using var client = new CopilotClient(new CopilotClientOptions { Connection = RuntimeConnection.ForUri(server.Url) });
+        await using var session = await client.CreateSessionAsync(new SessionConfig
+        {
+            OnPermissionRequest = PermissionHandler.ApproveAll
+        });
+
+        var response = await session.SendAndWaitAsync(
+            new MessageOptions { Prompt = "complete from delayed legacy idle" },
+            timeout: TimeSpan.FromSeconds(3));
+
+        Assert.NotNull(response);
+        Assert.Equal("completed response", response.Data.Content);
+        Assert.Contains(server.Requests, request => request.Method == "session.tasks.waitForPending");
+    }
+
     [Fact]
     public async Task SendAndWaitAsync_DroppedIdle_Fallback_Flushes_Preceding_Event_Handlers()
     {
@@ -624,6 +644,8 @@ private sealed class FakeCopilotServer : IAsyncDisposable
         private bool _failRuntimeShutdown;
         private bool _emitCompletionWithoutIdle;
         private bool _delayCompletionEvents;
+        private bool _emitDelayedIdle;
+        private bool _fallbackMethodsUnavailable;
         private bool _reactivateDuringFinalBarrier;
         private bool _hasActiveWork;
         private int _activityRequestCount;
@@ -702,6 +724,13 @@ public void ConfigureDroppedIdleCompletion(bool delayEvents = false)
             }
         }
 
+        public void ConfigureLegacyRuntimeCompletion()
+        {
+            ConfigureDroppedIdleCompletion();
+            _emitDelayedIdle = true;
+            _fallbackMethodsUnavailable = true;
+        }
+
         public void ReleaseCompletionEvents()
         {
             _allowCompletionEvents.TrySetResult();
@@ -786,6 +815,22 @@ private async Task HandleRequestAsync(Stream stream, JsonElement request, Cancel
                 _requests.Add(new RpcRequestRecord(method!, paramsElement));
             }
 
+            if (_fallbackMethodsUnavailable
+                && method is "session.tasks.waitForPending" or "session.metadata.activity")
+            {
+                await WriteMessageAsync(stream, new Dictionary<string, object?>
+                {
+                    ["jsonrpc"] = "2.0",
+                    ["id"] = id,
+                    ["error"] = new Dictionary<string, object?>
+                    {
+                        ["code"] = -32601,
+                        ["message"] = $"Method not found: {method}"
+                    }
+                }, cancellationToken);
+                return;
+            }
+
             var activityRequestNumber = 0;
             if (method == "session.metadata.activity")
             {
@@ -926,6 +971,27 @@ private async Task EmitCompletionWithoutIdleAsync(Stream stream, CancellationTok
                     }
                 }
             }, cancellationToken);
+
+            if (_emitDelayedIdle)
+            {
+                await Task.Delay(TimeSpan.FromMilliseconds(500), cancellationToken);
+                await WriteMessageAsync(stream, new Dictionary<string, object?>
+                {
+                    ["jsonrpc"] = "2.0",
+                    ["method"] = "session.event",
+                    ["params"] = new Dictionary<string, object?>
+                    {
+                        ["sessionId"] = _lastSessionId,
+                        ["event"] = new Dictionary<string, object?>
+                        {
+                            ["type"] = "session.idle",
+                            ["id"] = Guid.NewGuid().ToString(),
+                            ["timestamp"] = DateTimeOffset.UtcNow.ToString("O"),
+                            ["data"] = new Dictionary<string, object?>()
+                        }
+                    }
+                }, cancellationToken);
+            }
         }
 
         private Dictionary<string, object?> CreateSessionResult(JsonElement request)