Merge pull request #411 from jongalloway/fix/disable-task-store-di-scope-bug

fix: disable InMemoryMcpTaskStore to avoid ObjectDisposedException (upstream SDK bug)

Author: jongalloway

DotNetMcp.Tests/Server/McpConformanceTests.cs

@@ -713,34 +713,26 @@ public async Task Server_CompleteHandler_ShouldReturnConfigurationSuggestions()
 
     #endregion
 
-    #region MCP Task Support Tests
+    #region MCP Task Support Tests (Graceful Degradation)
 
-    [Fact]
-    public void Server_ShouldAdvertiseTasksCapability()
-    {
-        // Arrange
-        Assert.NotNull(_client);
-
-        // Assert - server should expose tasks capability (InMemoryMcpTaskStore is registered)
-        Assert.NotNull(_client.ServerCapabilities);
-        Assert.NotNull(_client.ServerCapabilities.Tasks);
-    }
+    // Task support is intentionally disabled: MCP SDK v1.1.0's ExecuteToolAsTaskAsync
+    // disposes the DI scope before the background task resolves services, causing
+    // ObjectDisposedException on every tool call. Without InMemoryMcpTaskStore,
+    // the server runs tools synchronously and does not advertise task capabilities.
 
     [Fact]
-    public void Server_TasksCapability_ShouldSupportListAndCancel()
+    public void Server_ShouldNotAdvertiseTasksCapability_WhenTaskStoreNotRegistered()
     {
         // Arrange
         Assert.NotNull(_client);
 
-        // Assert
-        var tasks = _client.ServerCapabilities?.Tasks;
-        Assert.NotNull(tasks);
-        Assert.NotNull(tasks.List);
-        Assert.NotNull(tasks.Cancel);
+        // Assert - no task store means no tasks capability advertised
+        Assert.NotNull(_client.ServerCapabilities);
+        Assert.Null(_client.ServerCapabilities.Tasks);
     }
 
     [Fact]
-    public async Task Server_DotnetProject_ShouldHaveTaskSupport()
+    public async Task Server_DotnetProject_ShouldDeclareTaskSupportOptional()
     {
         // Arrange
         Assert.NotNull(_client);
@@ -749,77 +741,24 @@ public async Task Server_DotnetProject_ShouldHaveTaskSupport()
         var tools = await _client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken);
         var projectTool = tools.FirstOrDefault(t => t.Name == "dotnet_project");
 
-        // Assert - dotnet_project should declare TaskSupport = Optional so clients can run
-        // long operations (build, test, publish) as async tasks
+        // Assert - the tool attribute declares TaskSupport = Optional so it's ready when
+        // task support is re-enabled by un-commenting the IMcpTaskStore registration in Program.cs
+        // (pending fix of https://github.com/modelcontextprotocol/csharp-sdk/issues/1430).
+        // Without a task store registered, the SDK runs it synchronously inline (graceful degradation).
         Assert.NotNull(projectTool);
         var execution = projectTool.ProtocolTool.Execution;
         Assert.NotNull(execution);
         Assert.Equal(ModelContextProtocol.Protocol.ToolTaskSupport.Optional, execution.TaskSupport);
     }
 
     [Fact]
-    public async Task Server_TaskList_ShouldReturnEmptyWhenNoTasksRunning()
+    public async Task Server_DotnetProject_ShouldWorkSynchronously()
     {
-        // Arrange
+        // Arrange - verify tools work reliably via normal tools/call (no tasks)
         Assert.NotNull(_client);
 
-        // Act
-        var tasks = await _client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken);
-
-        // Assert - no tasks should be running at server start
-        Assert.NotNull(tasks);
-    }
-
-    [Fact]
-    public async Task Server_DotnetProject_TaskMode_ShouldCompleteSuccessfully()
-    {
-        // Arrange - exercise the full task lifecycle: create task → poll → get result.
-        // Uses Build with a nonexistent project so the operation is fast but still
-        // exercises the entire task pipeline including the error-handling filter.
-        Assert.NotNull(_client);
-
-        // Act - invoke dotnet_project as task (the dedicated CallToolAsTaskAsync API)
-        var mcpTask = await _client.CallToolAsTaskAsync(
-            "dotnet_project",
-            new Dictionary<string, object?>
-            {
-                ["action"] = "Build",
-                ["project"] = "nonexistent.csproj"
-            },
-            cancellationToken: TestContext.Current.CancellationToken);
-
-        // Assert - task was created successfully
-        Assert.NotNull(mcpTask);
-        Assert.NotNull(mcpTask.TaskId);
-        Assert.NotEmpty(mcpTask.TaskId);
-
-        // Poll for completion — GetTaskResultAsync blocks until terminal state
-        var resultJson = await _client.GetTaskResultAsync(
-            mcpTask.TaskId,
-            cancellationToken: TestContext.Current.CancellationToken);
-
-        // The key validation: the task infrastructure returns a structured result JSON
-        // instead of throwing "unknown error". The underlying tool may report a build
-        // failure (nonexistent project), so the task status may be Completed or Failed —
-        // what matters is that a proper result is returned rather than an opaque error.
-        Assert.NotEqual(default, resultJson);
-
-        // Verify the task reached a terminal state
-        var finalTask = await _client.GetTaskAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken);
-        Assert.NotNull(finalTask);
-        Assert.True(
-            finalTask.Status == McpTaskStatus.Completed || finalTask.Status == McpTaskStatus.Failed,
-            $"Task should be in a terminal state but was: {finalTask.Status}");
-    }
-
-    [Fact]
-    public async Task Server_DotnetProject_TaskMode_ShouldAppearInTaskList()
-    {
-        // Arrange - verify that a task-mode call is tracked in the task store.
-        Assert.NotNull(_client);
-
-        // Act - start a fast task-mode operation
-        var mcpTask = await _client.CallToolAsTaskAsync(
+        // Act - standard synchronous tool call
+        var result = await _client.CallToolAsync(
             "dotnet_project",
             new Dictionary<string, object?>
             {
@@ -828,15 +767,10 @@ public async Task Server_DotnetProject_TaskMode_ShouldAppearInTaskList()
             },
             cancellationToken: TestContext.Current.CancellationToken);
 
-        Assert.NotNull(mcpTask);
-
-        // Wait for it to complete before checking the list
-        await _client.GetTaskResultAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken);
-
-        // Assert - the completed task should still be in the list
-        var allTasks = await _client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken);
-        Assert.NotNull(allTasks);
-        Assert.Contains(allTasks, t => t.TaskId == mcpTask.TaskId);
+        // Assert - tool returns a result (may be an error about missing project, but
+        // the call itself should not throw ObjectDisposedException)
+        Assert.NotNull(result);
+        Assert.NotEmpty(result.Content);
     }
 
     #endregion

DotNetMcp.Tests/Server/ServerCapabilitiesTests.cs

@@ -210,7 +210,7 @@ public async Task DotnetServerCapabilities_SdkVersions_Lts_IsNet100()
     }
 
     [Fact]
-    public async Task DotnetServerCapabilities_Supports_AsyncTasks_IsTrue()
+    public async Task DotnetServerCapabilities_Supports_AsyncTasks_IsFalse()
     {
         // Act
         var result = (await _tools.DotnetServerCapabilities()).GetText();
@@ -220,8 +220,8 @@ public async Task DotnetServerCapabilities_Supports_AsyncTasks_IsTrue()
             .GetProperty("asyncTasks")
             .GetBoolean();
 
-        // Assert - MCP Task support is enabled via InMemoryMcpTaskStore
-        Assert.True(asyncTasks);
+        // Assert - MCP Task support disabled due to SDK v1.1.0 DI scope lifetime bug
+        Assert.False(asyncTasks);
     }
 
     [Fact]
@@ -262,7 +262,7 @@ public async Task DotnetServerCapabilities_JsonSchema_MatchesExpectedStructure()
         Assert.True(capabilities.Supports.MachineReadable);
         Assert.True(capabilities.Supports.Cancellation);
         Assert.True(capabilities.Supports.Telemetry);
-        Assert.True(capabilities.Supports.AsyncTasks);
+        Assert.False(capabilities.Supports.AsyncTasks);
         Assert.True(capabilities.Supports.Prompts);
         Assert.True(capabilities.Supports.Elicitation);
         Assert.True(capabilities.Supports.Completions);

DotNetMcp/Program.cs

@@ -21,9 +21,12 @@
 // Register ProcessSessionManager as a singleton
 builder.Services.AddSingleton<ProcessSessionManager>();
 
-// Register InMemoryMcpTaskStore to enable MCP Task support for long-running operations.
-// This allows AI clients to run build/test/publish as async tasks with polling and cancellation.
-builder.Services.AddSingleton<IMcpTaskStore, InMemoryMcpTaskStore>();
+// TODO: Re-enable InMemoryMcpTaskStore once the MCP SDK fixes the DI scope lifetime bug.
+// Upstream issue: https://github.com/modelcontextprotocol/csharp-sdk/issues/1430
+// MCP SDK v1.1.0's ExecuteToolAsTaskAsync disposes the request-scoped IServiceProvider
+// before the background task resolves services, causing ObjectDisposedException on every
+// tool call. Without a task store, the SDK runs tools synchronously inline.
+// builder.Services.AddSingleton<IMcpTaskStore, InMemoryMcpTaskStore>();
 
 // Register ToolMetricsAccumulator for in-memory telemetry collection.
 // The accumulator is also captured by the telemetry filter added below.

DotNetMcp/Tools/Cli/DotNetCliTools.Core.cs

@@ -21,6 +21,7 @@ public sealed partial class DotNetCliTools
     private readonly ProcessSessionManager _processSessionManager;
     private readonly ToolMetricsAccumulator? _metricsAccumulator;
     private readonly ResourceSubscriptionManager? _subscriptions;
+    private readonly IMcpTaskStore? _taskStore;
 
     // Constants for server capability discovery
     private const string DefaultServerVersion = "1.0.0";
@@ -30,14 +31,15 @@ public sealed partial class DotNetCliTools
     private const int MaxSamplingPromptLength = 4000;
     private const int MaxSamplingResponseTokens = 256;
 
-    public DotNetCliTools(ILogger<DotNetCliTools> logger, ConcurrencyManager concurrencyManager, ProcessSessionManager processSessionManager, ToolMetricsAccumulator? metricsAccumulator = null, ResourceSubscriptionManager? subscriptions = null)
+    public DotNetCliTools(ILogger<DotNetCliTools> logger, ConcurrencyManager concurrencyManager, ProcessSessionManager processSessionManager, ToolMetricsAccumulator? metricsAccumulator = null, ResourceSubscriptionManager? subscriptions = null, IMcpTaskStore? taskStore = null)
     {
         // DI guarantees logger is never null
         _logger = logger!;
         _concurrencyManager = concurrencyManager!;
         _processSessionManager = processSessionManager!;
         _metricsAccumulator = metricsAccumulator;
         _subscriptions = subscriptions;
+        _taskStore = taskStore;
     }
 
     private async Task<string> ExecuteDotNetCommand(string arguments, CancellationToken cancellationToken = default, string? workingDirectory = null)

DotNetMcp/Tools/Cli/DotNetCliTools.Misc.cs

@@ -71,7 +71,7 @@ public async partial Task<CallToolResult> DotnetServerCapabilities()
                 Cancellation = true,
                 Telemetry = true,  // SDK v0.6+ supports request duration logging and OpenTelemetry semantic conventions
                 Metrics = true,    // In-memory per-tool metrics via MCP message filter (dotnet_server_metrics tool)
-                AsyncTasks = true,  // MCP Task support enabled: long-running operations (build, test, publish) can run as async tasks
+                AsyncTasks = _taskStore != null, // Derived from DI: true when IMcpTaskStore is registered; currently false (MCP SDK DI scope bug https://github.com/modelcontextprotocol/csharp-sdk/issues/1430)
                 Prompts = true,     // Predefined prompt catalog: create_new_webapi, add_package_and_restore, run_tests_with_coverage
                 Elicitation = true,  // Elicitation for confirmation before destructive ops (Clean, solution Remove)
                 McpLogging = true,   // MCP log notifications sent to client during key operations (build, test, publish, restore, package add/update)