Fix keyset pagination by sorting before applying cursor filter

Co-authored-by: eiriktsarpalis <2813363+eiriktsarpalis@users.noreply.github.com>

Author: Copilot

src/ModelContextProtocol.Core/Server/InMemoryMcpTaskStore.cs

@@ -27,10 +27,6 @@ namespace ModelContextProtocol;
 [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)]
 public sealed class InMemoryMcpTaskStore : IMcpTaskStore, IDisposable
 {
-    // Counter used for generating monotonically increasing task IDs, ensuring chronological ordering
-    // even when tasks are created within the same millisecond.
-    private static long s_taskIdCounter;
-
     private readonly ConcurrentDictionary<string, TaskEntry> _tasks = new();
     private readonly TimeSpan? _defaultTtl;
     private readonly TimeSpan? _maxTtl;
@@ -183,7 +179,7 @@ public Task<McpTask> CreateTaskAsync(
 
         if (!_tasks.TryAdd(taskId, entry))
         {
-            // Should never happen with counter-based IDs since each counter value is unique
+            // This should be extremely rare with GUID-based IDs
             throw new InvalidOperationException($"Task ID collision: {taskId}");
         }
 
@@ -337,20 +333,22 @@ public Task<ListTasksResult> ListTasksAsync(
             }
         }
 
-        // Stream enumeration - filter by session, exclude expired, apply keyset pagination
+        // Stream enumeration - filter by session, exclude expired
         var query = _tasks.Values
             .Where(e => sessionId == null || e.SessionId == sessionId)
             .Where(e => !IsExpired(e));
 
+        // Order by (CreatedAt, TaskId) for stable, deterministic pagination
+        // Must sort BEFORE applying keyset filter to ensure consistent comparison
+        var orderedQuery = query.OrderBy(e => (e.CreatedAt, e.TaskId));
+
         // Apply keyset filter if cursor provided: (CreatedAt, TaskId) > cursor
-        if (parsedCursor is { } parsedCursorValue)
-        {
-            query = query.Where(e => (e.CreatedAt, e.TaskId).CompareTo(parsedCursorValue) > 0);
-        }
+        // This runs on sorted data, so we skip items until we pass the cursor position
+        IEnumerable<TaskEntry> filteredQuery = parsedCursor is { } parsedCursorValue
+            ? orderedQuery.SkipWhile(e => (e.CreatedAt, e.TaskId).CompareTo(parsedCursorValue) <= 0)
+            : orderedQuery;
 
-        // Order by (CreatedAt, TaskId) for stable, deterministic pagination
-        var page = query
-            .OrderBy(e => (e.CreatedAt, e.TaskId))
+        var page = filteredQuery
             .Take(_pageSize + 1) // Take one extra to check if there's a next page
             .Select(e => e.ToMcpTask())
             .ToList();
@@ -421,15 +419,7 @@ public void Dispose()
         _cleanupTimer?.Dispose();
     }
 
-    private string GenerateTaskId()
-    {
-        // Use Interlocked.Increment to generate a monotonically increasing counter.
-        // This ensures task IDs maintain chronological ordering for keyset pagination,
-        // even when multiple tasks are created within the same millisecond.
-        // Format: {counter:D20}-{uniqueSuffix} where D20 ensures lexicographic sorting.
-        long counter = Interlocked.Increment(ref s_taskIdCounter);
-        return $"{counter:D20}-{Guid.NewGuid():N}";
-    }
+    private static string GenerateTaskId() => Guid.NewGuid().ToString("N");
 
     private static bool IsTerminalStatus(McpTaskStatus status) =>
         status is McpTaskStatus.Completed or McpTaskStatus.Failed or McpTaskStatus.Cancelled;