feat: add MCP Tasks, Extensions, and ToolExecution experimental APIs

Implement all missing experimental features from official MCP C# SDK v1.1.0:

- Tasks (QYLEXP001): McpTaskStatus, McpTask, IMcpTaskStore, InMemoryMcpTaskStore
  with protocol methods tasks/list, tasks/get, tasks/cancel
- Extensions: empty extensions object in capabilities for future extensibility
- ToolExecution: ToolTaskSupport enum (Forbidden/Optional/Required) on ToolAttribute
  and McpToolInfo, emitted as execution.taskSupport in tools/list
- Experimentals class with QYLEXP001/QYLEXP002 diagnostic ID constants
- ExperimentalAttribute polyfill for netstandard2.0

Hosting APIs (McpEndpoints, McpHost) accept optional IMcpTaskStore.
Generator extracts TaskSupport from [Tool] attribute and emits on McpToolInfo.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ANcpLua

AGENTS.md

@@ -53,7 +53,7 @@ src/
 │   ├── Extraction/                # ServerExtractor, ToolExtractor, ParameterExtractor
 │   ├── Models/                    # ServerModel, ToolModel, ToolParameterModel (value-equatable)
 │   └── Generation/                # DispatchEmitter, SchemaEmitter, OTelEmitter, JsonContextEmitter, MetadataEmitter
-└── Qyl.Agents/                    # Runtime: McpHost (stdio), McpProtocolHandler (JSON-RPC)
+└── Qyl.Agents/                    # Runtime: McpHost (stdio), McpEndpoints (HTTP), McpProtocolHandler (JSON-RPC), Tasks/
 
 tests/
 ├── NetAgents.Tests/
@@ -63,6 +63,15 @@ tests/
 shared/Polyfills/                  # netstandard2.0 polyfills for Abstractions + Generator
 ```
 
+## Relationship to official MCP C# SDK
+
+- Qyl.Agents is a compile-time source generator — no DI container, no runtime reflection.
+- `McpEndpoints.MapMcpServer<T>()` ≈ official SDK `MapMcp()`.
+- Official SDK's `AddMcpServer()`/`WithHttpTransport()`/`WithTools<T>()` DI pattern has no equivalent — tools are wired at compile time.
+- Official SDK experimental `RunSessionHandler` is not applicable (stateless HTTP POST, no sessions).
+- Tasks (`MCPEXP001`) implemented in `Qyl.Agents.Tasks` — `IMcpTaskStore`, `InMemoryMcpTaskStore`, protocol methods.
+- `[Experimental]` polyfill exists in `shared/Polyfills/` but must NOT be applied to types consumed by `Qyl.Agents` runtime — the internal polyfill metadata leaks to net10.0 consumers and causes QYLEXP errors that cannot be suppressed per repo rules.
+
 ## Cross-repo dependencies
 
 - `Qyl.Agents.Generator` -> `ANcpLua.Roslyn.Utilities`

shared/Polyfills/ExperimentalAttribute.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// <auto-generated />
+
+#nullable enable
+
+#if !NET8_0_OR_GREATER
+
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+///     Indicates that an API is experimental and it may change in the future.
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Assembly |
+    AttributeTargets.Module |
+    AttributeTargets.Class |
+    AttributeTargets.Struct |
+    AttributeTargets.Enum |
+    AttributeTargets.Constructor |
+    AttributeTargets.Method |
+    AttributeTargets.Property |
+    AttributeTargets.Field |
+    AttributeTargets.Event |
+    AttributeTargets.Interface |
+    AttributeTargets.Delegate,
+    Inherited = false)]
+[ExcludeFromCodeCoverage]
+internal sealed class ExperimentalAttribute : Attribute
+{
+    public ExperimentalAttribute(string diagnosticId)
+    {
+        DiagnosticId = diagnosticId;
+    }
+
+    /// <summary>Gets the ID that the compiler will use when reporting a use of the API the attribute applies to.</summary>
+    public string DiagnosticId { get; }
+
+    /// <summary>Gets or sets the URL for corresponding documentation.</summary>
+    public string? UrlFormat { get; set; }
+}
+
+#endif

src/Qyl.Agents.Abstractions/Experimentals.cs

@@ -0,0 +1,32 @@
+namespace Qyl.Agents;
+
+/// <summary>
+///     Diagnostic IDs for APIs annotated with <see cref="System.Diagnostics.CodeAnalysis.ExperimentalAttribute" />.
+///     <list type="bullet">
+///         <item><c>QYLEXP001</c> — experimental MCP specification features (Tasks, Extensions).</item>
+///         <item><c>QYLEXP002</c> — experimental SDK-level extensibility hooks.</item>
+///     </list>
+/// </summary>
+public static class Experimentals
+{
+    /// <summary>Diagnostic ID for experimental MCP Tasks feature.</summary>
+    public const string Tasks_DiagnosticId = "QYLEXP001";
+
+    /// <summary>Message for experimental MCP Tasks feature.</summary>
+    public const string Tasks_Message =
+        "The Tasks feature is experimental per the MCP specification and is subject to change.";
+
+    /// <summary>Diagnostic ID for experimental MCP Extensions feature.</summary>
+    public const string Extensions_DiagnosticId = "QYLEXP001";
+
+    /// <summary>Message for experimental MCP Extensions feature.</summary>
+    public const string Extensions_Message =
+        "The Extensions feature is part of a future MCP specification version and is subject to change.";
+
+    /// <summary>Diagnostic ID for experimental SDK extensibility hooks.</summary>
+    public const string Sdk_DiagnosticId = "QYLEXP002";
+
+    /// <summary>Message for experimental SDK extensibility hooks.</summary>
+    public const string Sdk_Message =
+        "This API is experimental and may be removed or changed in a future release.";
+}

src/Qyl.Agents.Abstractions/McpToolInfo.cs

@@ -25,4 +25,7 @@ public sealed class McpToolInfo
 
     /// <summary>Safety annotation: open-world hint. Emitted as <c>openWorldHint</c> in MCP wire format.</summary>
     public bool? OpenWorldHint { get; init; }
+
+    /// <summary>Task execution support. Emitted as <c>execution.taskSupport</c> in MCP wire format.</summary>
+    public ToolTaskSupport TaskSupport { get; init; }
 }

src/Qyl.Agents.Abstractions/Qyl.Agents.Abstractions.csproj

@@ -23,5 +23,7 @@
              Link="Polyfills\CompilerFeatureRequiredAttribute.cs"/>
     <Compile Include="..\..\shared\Polyfills\SetsRequiredMembersAttribute.cs"
              Link="Polyfills\SetsRequiredMembersAttribute.cs"/>
+    <Compile Include="..\..\shared\Polyfills\ExperimentalAttribute.cs"
+             Link="Polyfills\ExperimentalAttribute.cs"/>
   </ItemGroup>
 </Project>

src/Qyl.Agents.Abstractions/ToolAttribute.cs

@@ -33,4 +33,7 @@ public ToolAttribute(string name)
 
     /// <summary>Hint that the tool interacts with open-world systems.</summary>
     public ToolHint OpenWorld { get; set; }
+
+    /// <summary>Declares whether the tool supports long-running task execution.</summary>
+    public ToolTaskSupport TaskSupport { get; set; }
 }

src/Qyl.Agents.Abstractions/ToolTaskSupport.cs

@@ -0,0 +1,20 @@
+namespace Qyl.Agents;
+
+/// <summary>
+///     Declares whether a tool supports long-running task execution.
+///     Emitted as <c>execution.taskSupport</c> in the MCP <c>tools/list</c> response.
+/// </summary>
+public enum ToolTaskSupport : byte
+{
+    /// <summary>Developer did not declare — omitted from wire format.</summary>
+    Unset = 0,
+
+    /// <summary>Task execution is forbidden for this tool.</summary>
+    Forbidden = 1,
+
+    /// <summary>Task execution is optional — server may return a task or an immediate result.</summary>
+    Optional = 2,
+
+    /// <summary>Task execution is required — server always returns a task.</summary>
+    Required = 3
+}

src/Qyl.Agents.Generator/Extraction/ToolExtractor.cs

@@ -44,6 +44,7 @@ public static DiagnosticFlow<ToolModel> Extract(
         var destructive = ReadHint(toolAttr, "Destructive");
         var idempotent = ReadHint(toolAttr, "Idempotent");
         var openWorld = ReadHint(toolAttr, "OpenWorld");
+        var taskSupport = ReadTaskSupport(toolAttr);
 
         var flow = ParameterExtractor.ExtractParameters(method, cancellationToken)
             .Select(parameters => new ToolModel(
@@ -57,7 +58,8 @@ public static DiagnosticFlow<ToolModel> Extract(
                 readOnly,
                 destructive,
                 idempotent,
-                openWorld));
+                openWorld,
+                taskSupport));
 
         if (readOnly == ToolHintValue.Unset &&
             destructive == ToolHintValue.Unset &&
@@ -115,6 +117,21 @@ private static ToolHintValue ReadHint(AttributeData? attr, string name)
         return ToolHintValue.Unset;
     }
 
+    private static ToolTaskSupportValue ReadTaskSupport(AttributeData? attr)
+    {
+        if (attr is null || attr.NamedArguments.IsDefaultOrEmpty)
+            return ToolTaskSupportValue.Unset;
+
+        foreach (var arg in attr.NamedArguments)
+        {
+            if (string.Equals(arg.Key, "TaskSupport", StringComparison.Ordinal) &&
+                arg.Value.Value is not null)
+                return (ToolTaskSupportValue)Convert.ToByte(arg.Value.Value);
+        }
+
+        return ToolTaskSupportValue.Unset;
+    }
+
     private static bool HasCancellationToken(IMethodSymbol method)
     {
         foreach (var p in method.Parameters)

src/Qyl.Agents.Generator/Generation/MetadataEmitter.cs

@@ -53,6 +53,9 @@ public static void Emit(IndentedStringBuilder sb, ServerModel server)
                         if (tool.OpenWorld != ToolHintValue.Unset)
                             sb.AppendLine(
                                 $"OpenWorldHint = {HintBool(tool.OpenWorld)},");
+                        if (tool.TaskSupport != ToolTaskSupportValue.Unset)
+                            sb.AppendLine(
+                                $"TaskSupport = global::Qyl.Agents.ToolTaskSupport.{tool.TaskSupport},");
                     }
 
                     sb.AppendLine(",");

src/Qyl.Agents.Generator/Models/ToolModel.cs

@@ -21,7 +21,8 @@ internal readonly record struct ToolModel(
     ToolHintValue ReadOnly,
     ToolHintValue Destructive,
     ToolHintValue Idempotent,
-    ToolHintValue OpenWorld)
+    ToolHintValue OpenWorld,
+    ToolTaskSupportValue TaskSupport)
 {
     public byte ReadOnlyHint => (byte)ReadOnly;
     public byte IdempotentHint => (byte)Idempotent;