From 361962d2369765658c4a62178074673b8113e6a8 Mon Sep 17 00:00:00 2001
From: alzimmermsft <48699787+alzimmermsft@users.noreply.github.com>
Date: Wed, 17 Jun 2026 14:38:55 -0400
Subject: [PATCH 1/5] Checkpoint work

---
 .../Subscription/SubscriptionCommand`2.cs     |  13 +-
 .../src/Commands/BaseCommand`2.cs             |  23 ++-
 .../src/Options/OptionBinder.cs               | 136 +++-------------
 .../src/Options/OptionCreators.cs             | 151 ++++++++++++++++++
 .../src/Options/OptionDescriptor.cs           |  13 +-
 .../Options/OptionBinderTests.cs              | 103 +++++++-----
 6 files changed, 265 insertions(+), 174 deletions(-)
 create mode 100644 core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs

diff --git a/core/Azure.Mcp.Core/src/Commands/Subscription/SubscriptionCommand`2.cs b/core/Azure.Mcp.Core/src/Commands/Subscription/SubscriptionCommand`2.cs
index 80dd1bda63..ae6e31f1ae 100644
--- a/core/Azure.Mcp.Core/src/Commands/Subscription/SubscriptionCommand`2.cs
+++ b/core/Azure.Mcp.Core/src/Commands/Subscription/SubscriptionCommand`2.cs
@@ -9,15 +9,10 @@
 namespace Azure.Mcp.Core.Commands.Subscription;
 
 public abstract class SubscriptionCommand<
-    [DynamicallyAccessedMembers(TrimAnnotations.CommandAnnotations)] TOptions, TResult>
+    [DynamicallyAccessedMembers(TrimAnnotations.CommandAnnotations)] TOptions, TResult>(ISubscriptionResolver subscriptionResolver)
      : AuthenticatedCommand<TOptions, TResult> where TOptions : class, ISubscriptionOption
 {
-    private readonly ISubscriptionResolver _subscriptionResolver;
-
-    protected SubscriptionCommand(ISubscriptionResolver subscriptionResolver)
-    {
-        _subscriptionResolver = subscriptionResolver;
-    }
+    private readonly ISubscriptionResolver _subscriptionResolver = subscriptionResolver;
 
     public override void ValidateOptions(TOptions options, ValidationResult validationResult)
     {
@@ -29,11 +24,9 @@ public override void ValidateOptions(TOptions options, ValidationResult validati
         }
     }
 
-    public override TOptions BindOptions(ParseResult parseResult)
+    public override void PostBindOptions(TOptions options)
     {
-        var options = base.BindOptions(parseResult);
         // Always post-process subscription via resolver (env var / CLI profile fallback)
         options.Subscription = _subscriptionResolver.ResolveSubscription(options.Subscription);
-        return options;
     }
 }
diff --git a/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs b/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs
index 74af73d10a..4419beab50 100644
--- a/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs
+++ b/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs
@@ -23,6 +23,7 @@ public abstract class BaseCommand<[DynamicallyAccessedMembers(TrimAnnotations.Co
     private const string TroubleshootingUrl = "https://aka.ms/azmcp/troubleshooting";
 
     private readonly Command _command;
+    private readonly OptionDescriptor[] _descriptors;
 
     [UnconditionalSuppressMessage("Trimming", "IL2075:UnrecognizedReflectionPattern",
         Justification = "CommandMetadataAttribute is only applied to concrete command types that are rooted by DI service registration.")]
@@ -45,7 +46,8 @@ protected BaseCommand()
         Metadata = attr.ToToolMetadata();
 
         _command = new ExtendedCommand(this, Name, Description);
-        OptionBinder.RegisterOptions<TOptions>(_command);
+        _descriptors = OptionDescriptor.FromType<TOptions>();
+        OptionBinder.RegisterOptions<TOptions>(_command, _descriptors);
     }
 
     public string Id { get; }
@@ -56,11 +58,26 @@ protected BaseCommand()
 
     public Command GetCommand() => _command;
 
-    public virtual TOptions BindOptions(ParseResult parseResult)
+    public TOptions BindOptions(ParseResult parseResult)
     {
-        return OptionBinder.BindOptions<TOptions>(parseResult);
+        var options = OptionBinder.BindOptions<TOptions>(parseResult, _descriptors);
+        PostBindOptions(options);
+        return options;
     }
 
+    /// <summary>
+    /// Called after the options have been bound to the command to perform any additional setup or initialization.
+    /// </summary>
+    /// <param name="options">The options that have been bound.</param>
+    public virtual void PostBindOptions(TOptions options)
+    {
+    }
+
+    /// <summary>
+    /// Validates the options after they have been bound.
+    /// </summary>
+    /// <param name="options">The options to validate.</param>
+    /// <param name="validationResult">The validation result to populate.</param>
     public virtual void ValidateOptions(TOptions options, ValidationResult validationResult)
     {
     }
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs b/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
index be54ce8973..cc0babf168 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using System.Collections.Concurrent;
-using System.CommandLine.Parsing;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Reflection;
@@ -21,111 +19,14 @@ public static class OptionBinder
         DynamicallyAccessedMemberTypes.PublicProperties |
         DynamicallyAccessedMemberTypes.PublicParameterlessConstructor;
 
-    /// <summary>
-    /// To prevent native AOT builds from trimming away the filled generic Options<T> methods, we have to maintain a
-    /// centralized factory pattern. Each entry provides both the option factory (for registration) and value binder
-    /// (for parsing). If a type is not in this dictionary and is not an enum, it is unsupported and will be rejected
-    /// at option registration time.
-    /// </summary>
-    private static readonly ConcurrentDictionary<Type, OptionTypeHandler> s_typeHandlers = new()
-    {
-        // String
-        [typeof(string)] = new(name => new Option<string>(name), (pr, n) => pr.GetValueOrDefault<string>(n)),
-        [typeof(string[])] = new(name => new Option<string[]>(name), (pr, n) => pr.GetValueOrDefault<string[]>(n)),
-
-        // Boolean
-        [typeof(bool)] = new(name => new Option<bool>(name), (pr, n) => pr.GetValueOrDefault<bool>(n)),
-        [typeof(bool?)] = new(name => new Option<bool?>(name), (pr, n) => pr.GetValueOrDefault<bool?>(n)),
-        [typeof(bool[])] = new(name => new Option<bool[]>(name), (pr, n) => pr.GetValueOrDefault<bool[]>(n)),
-
-        // Int
-        [typeof(int)] = new(name => new Option<int>(name), (pr, n) => pr.GetValueOrDefault<int>(n)),
-        [typeof(int?)] = new(name => new Option<int?>(name), (pr, n) => pr.GetValueOrDefault<int?>(n)),
-        [typeof(int[])] = new(name => new Option<int[]>(name), (pr, n) => pr.GetValueOrDefault<int[]>(n)),
-
-        // Long
-        [typeof(long)] = new(name => new Option<long>(name), (pr, n) => pr.GetValueOrDefault<long>(n)),
-        [typeof(long?)] = new(name => new Option<long?>(name), (pr, n) => pr.GetValueOrDefault<long?>(n)),
-        [typeof(long[])] = new(name => new Option<long[]>(name), (pr, n) => pr.GetValueOrDefault<long[]>(n)),
-
-        // Short
-        [typeof(short)] = new(name => new Option<short>(name), (pr, n) => pr.GetValueOrDefault<short>(n)),
-        [typeof(short?)] = new(name => new Option<short?>(name), (pr, n) => pr.GetValueOrDefault<short?>(n)),
-        [typeof(short[])] = new(name => new Option<short[]>(name), (pr, n) => pr.GetValueOrDefault<short[]>(n)),
-
-        // Byte
-        [typeof(byte)] = new(name => new Option<byte>(name), (pr, n) => pr.GetValueOrDefault<byte>(n)),
-        [typeof(byte?)] = new(name => new Option<byte?>(name), (pr, n) => pr.GetValueOrDefault<byte?>(n)),
-        [typeof(byte[])] = new(name => new Option<byte[]>(name), (pr, n) => pr.GetValueOrDefault<byte[]>(n)),
-
-        // SByte
-        [typeof(sbyte)] = new(name => new Option<sbyte>(name), (pr, n) => pr.GetValueOrDefault<sbyte>(n)),
-        [typeof(sbyte?)] = new(name => new Option<sbyte?>(name), (pr, n) => pr.GetValueOrDefault<sbyte?>(n)),
-        [typeof(sbyte[])] = new(name => new Option<sbyte[]>(name), (pr, n) => pr.GetValueOrDefault<sbyte[]>(n)),
-
-        // UShort
-        [typeof(ushort)] = new(name => new Option<ushort>(name), (pr, n) => pr.GetValueOrDefault<ushort>(n)),
-        [typeof(ushort?)] = new(name => new Option<ushort?>(name), (pr, n) => pr.GetValueOrDefault<ushort?>(n)),
-        [typeof(ushort[])] = new(name => new Option<ushort[]>(name), (pr, n) => pr.GetValueOrDefault<ushort[]>(n)),
-
-        // UInt
-        [typeof(uint)] = new(name => new Option<uint>(name), (pr, n) => pr.GetValueOrDefault<uint>(n)),
-        [typeof(uint?)] = new(name => new Option<uint?>(name), (pr, n) => pr.GetValueOrDefault<uint?>(n)),
-        [typeof(uint[])] = new(name => new Option<uint[]>(name), (pr, n) => pr.GetValueOrDefault<uint[]>(n)),
-
-        // ULong
-        [typeof(ulong)] = new(name => new Option<ulong>(name), (pr, n) => pr.GetValueOrDefault<ulong>(n)),
-        [typeof(ulong?)] = new(name => new Option<ulong?>(name), (pr, n) => pr.GetValueOrDefault<ulong?>(n)),
-        [typeof(ulong[])] = new(name => new Option<ulong[]>(name), (pr, n) => pr.GetValueOrDefault<ulong[]>(n)),
-
-        // Float
-        [typeof(float)] = new(name => new Option<float>(name), (pr, n) => pr.GetValueOrDefault<float>(n)),
-        [typeof(float?)] = new(name => new Option<float?>(name), (pr, n) => pr.GetValueOrDefault<float?>(n)),
-        [typeof(float[])] = new(name => new Option<float[]>(name), (pr, n) => pr.GetValueOrDefault<float[]>(n)),
-
-        // Double
-        [typeof(double)] = new(name => new Option<double>(name), (pr, n) => pr.GetValueOrDefault<double>(n)),
-        [typeof(double?)] = new(name => new Option<double?>(name), (pr, n) => pr.GetValueOrDefault<double?>(n)),
-        [typeof(double[])] = new(name => new Option<double[]>(name), (pr, n) => pr.GetValueOrDefault<double[]>(n)),
-
-        // Decimal
-        [typeof(decimal)] = new(name => new Option<decimal>(name), (pr, n) => pr.GetValueOrDefault<decimal>(n)),
-        [typeof(decimal?)] = new(name => new Option<decimal?>(name), (pr, n) => pr.GetValueOrDefault<decimal?>(n)),
-        [typeof(decimal[])] = new(name => new Option<decimal[]>(name), (pr, n) => pr.GetValueOrDefault<decimal[]>(n)),
-
-        // Char
-        [typeof(char)] = new(name => new Option<char>(name), (pr, n) => pr.GetValueOrDefault<char>(n)),
-        [typeof(char?)] = new(name => new Option<char?>(name), (pr, n) => pr.GetValueOrDefault<char?>(n)),
-        [typeof(char[])] = new(name => new Option<char[]>(name), (pr, n) => pr.GetValueOrDefault<char[]>(n)),
-
-        // DateTime
-        [typeof(DateTime)] = new(name => new Option<DateTime>(name), (pr, n) => pr.GetValueOrDefault<DateTime>(n)),
-        [typeof(DateTime?)] = new(name => new Option<DateTime?>(name), (pr, n) => pr.GetValueOrDefault<DateTime?>(n)),
-        [typeof(DateTime[])] = new(name => new Option<DateTime[]>(name), (pr, n) => pr.GetValueOrDefault<DateTime[]>(n)),
-
-        // DateTimeOffset
-        [typeof(DateTimeOffset)] = new(name => new Option<DateTimeOffset>(name), (pr, n) => pr.GetValueOrDefault<DateTimeOffset>(n)),
-        [typeof(DateTimeOffset?)] = new(name => new Option<DateTimeOffset?>(name), (pr, n) => pr.GetValueOrDefault<DateTimeOffset?>(n)),
-        [typeof(DateTimeOffset[])] = new(name => new Option<DateTimeOffset[]>(name), (pr, n) => pr.GetValueOrDefault<DateTimeOffset[]>(n)),
-
-        // TimeSpan
-        [typeof(TimeSpan)] = new(name => new Option<TimeSpan>(name), (pr, n) => pr.GetValueOrDefault<TimeSpan>(n)),
-        [typeof(TimeSpan?)] = new(name => new Option<TimeSpan?>(name), (pr, n) => pr.GetValueOrDefault<TimeSpan?>(n)),
-        [typeof(TimeSpan[])] = new(name => new Option<TimeSpan[]>(name), (pr, n) => pr.GetValueOrDefault<TimeSpan[]>(n)),
-
-        // Guid
-        [typeof(Guid)] = new(name => new Option<Guid>(name), (pr, n) => pr.GetValueOrDefault<Guid>(n)),
-        [typeof(Guid?)] = new(name => new Option<Guid?>(name), (pr, n) => pr.GetValueOrDefault<Guid?>(n)),
-        [typeof(Guid[])] = new(name => new Option<Guid[]>(name), (pr, n) => pr.GetValueOrDefault<Guid[]>(n)),
-    };
-
     /// <summary>
     /// Registers System.CommandLine options on a command based on the public properties of <typeparamref name="TOptions"/>.
     /// </summary>
-    public static void RegisterOptions<[DynamicallyAccessedMembers(OptionBindingMembers)] TOptions>(Command command)
+    /// <param name="command">The command to register options on.</param>
+    /// <param name="descriptors">The option descriptors to register.</param>
+    public static void RegisterOptions<[DynamicallyAccessedMembers(OptionBindingMembers)] TOptions>(Command command, OptionDescriptor[] descriptors)
         where TOptions : class
     {
-        var descriptors = OptionDescriptor.FromType<TOptions>();
         foreach (var descriptor in descriptors)
         {
             var option = CreateOption(descriptor);
@@ -137,11 +38,12 @@ public static class OptionBinder
     /// Creates a new <typeparamref name="TOptions"/> instance and populates its properties
     /// from the parsed command-line values.
     /// </summary>
-    public static TOptions BindOptions<[DynamicallyAccessedMembers(OptionBindingMembers)] TOptions>(ParseResult parseResult)
+    /// <param name="parseResult">The parsed command-line values.</param>
+    /// <param name="descriptors">The option descriptors to bind.</param>
+    public static TOptions BindOptions<[DynamicallyAccessedMembers(OptionBindingMembers)] TOptions>(ParseResult parseResult, OptionDescriptor[] descriptors)
         where TOptions : class
     {
         var instance = (TOptions)CreateInstance(typeof(TOptions));
-        var descriptors = OptionDescriptor.FromType<TOptions>();
         List<string> missingOptions = [];
         List<string> errors = [];
         Dictionary<PropertyInfo, object>? parentInstances = null;
@@ -218,9 +120,8 @@ public static class OptionBinder
 
     private static Option CreateOption(OptionDescriptor descriptor)
     {
-        var name = $"--{descriptor.Name}";
-        var handler = GetHandler(descriptor.Type);
-        var option = handler.CreateOption(name);
+        var handler = GetHandler(descriptor);
+        var option = handler.CreateOption(descriptor);
         option.Description = descriptor.Description;
         option.Required = descriptor.Required;
         option.Hidden = descriptor.Hidden;
@@ -236,14 +137,18 @@ private static Option CreateOption(OptionDescriptor descriptor)
         return option;
     }
 
-    private static object? GetOptionValue(ParseResult parseResult, Type type, string optionName)
+    private static object? GetOptionValue(ParseResult parseResult, OptionDescriptor descriptor)
     {
-        var handler = GetHandler(type);
-        return handler.GetValue(parseResult, optionName);
+        var handler = GetHandler<T>(descriptor);
+        return handler.GetValue<T>(parseResult);
     }
 
-    private static OptionTypeHandler GetHandler(Type type)
+    private static OptionTypeHandler<T> GetHandler<T>(OptionDescriptor descriptor)
     {
+        if (descriptor.Type == typeof(int))
+        {
+            return new OptionTypeHandler<T>(descriptor, d => OptionCreators.Int(d));
+        }
         if (s_typeHandlers.TryGetValue(type, out var handler))
         {
             return handler;
@@ -305,10 +210,11 @@ private static object CreateInstance(Type type)
     }
 
     private sealed class OptionTypeHandler(
-        Func<string, Option> createOption,
-        Func<ParseResult, string, object?> getValue)
+        OptionDescriptor descriptor,
+        Func<OptionDescriptor, Option> createOption)
     {
-        public Option CreateOption(string name) => createOption(name);
-        public object? GetValue(ParseResult parseResult, string optionName) => getValue(parseResult, optionName);
+        private readonly Lazy<Option> _option = new(() => createOption(descriptor));
+        public Option CreateOption(OptionDescriptor descriptor) => _option.Value;
+        public object? GetValue(ParseResult parseResult) => parseResult.GetValueOrDefault(_option.Value);
     }
 }
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs b/core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs
new file mode 100644
index 0000000000..4619a6c714
--- /dev/null
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs
@@ -0,0 +1,151 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.Mcp.Core.Options;
+
+/// <summary>
+/// A class for creating option instances.
+/// </summary>
+internal static class OptionCreators
+{
+    // String
+    internal static Option<string> String(OptionDescriptor descriptor) => Single<string>(descriptor);
+    internal static Option<string?> NullableString(OptionDescriptor descriptor) => NullableSingle<string?>(descriptor);
+    internal static Option<string[]> StringArray(OptionDescriptor descriptor) => Multi<string[]>(descriptor);
+    internal static Option<string[]?> NullableStringArray(OptionDescriptor descriptor) => NullableMulti<string[]?>(descriptor);
+
+    // Boolean
+    internal static Option<bool> Bool(OptionDescriptor descriptor) => Single<bool>(descriptor);
+    internal static Option<bool?> NullableBool(OptionDescriptor descriptor) => NullableSingle<bool?>(descriptor);
+    internal static Option<bool[]> BoolArray(OptionDescriptor descriptor) => Multi<bool[]>(descriptor);
+    internal static Option<bool[]?> NullableBoolArray(OptionDescriptor descriptor) => NullableMulti<bool[]?>(descriptor);
+
+    // Int
+    internal static Option<int> Int(OptionDescriptor descriptor) => Single<int>(descriptor);
+    internal static Option<int?> NullableInt(OptionDescriptor descriptor) => NullableSingle<int?>(descriptor);
+    internal static Option<int[]> IntArray(OptionDescriptor descriptor) => Multi<int[]>(descriptor);
+    internal static Option<int[]?> NullableIntArray(OptionDescriptor descriptor) => NullableMulti<int[]?>(descriptor);
+
+    // Long
+    internal static Option<long> Long(OptionDescriptor descriptor) => Single<long>(descriptor);
+    internal static Option<long?> NullableLong(OptionDescriptor descriptor) => NullableSingle<long?>(descriptor);
+    internal static Option<long[]> LongArray(OptionDescriptor descriptor) => Multi<long[]>(descriptor);
+    internal static Option<long[]?> NullableLongArray(OptionDescriptor descriptor) => NullableMulti<long[]?>(descriptor);
+
+    // Short
+    internal static Option<short> Short(OptionDescriptor descriptor) => Single<short>(descriptor);
+    internal static Option<short?> NullableShort(OptionDescriptor descriptor) => NullableSingle<short?>(descriptor);
+    internal static Option<short[]> ShortArray(OptionDescriptor descriptor) => Multi<short[]>(descriptor);
+    internal static Option<short[]?> NullableShortArray(OptionDescriptor descriptor) => NullableMulti<short[]?>(descriptor);
+
+    // Byte
+    internal static Option<byte> Byte(OptionDescriptor descriptor) => Single<byte>(descriptor);
+    internal static Option<byte?> NullableByte(OptionDescriptor descriptor) => NullableSingle<byte?>(descriptor);
+    internal static Option<byte[]> ByteArray(OptionDescriptor descriptor) => Multi<byte[]>(descriptor);
+    internal static Option<byte[]?> NullableByteArray(OptionDescriptor descriptor) => NullableMulti<byte[]?>(descriptor);
+
+    // SByte
+    internal static Option<sbyte> SByte(OptionDescriptor descriptor) => Single<sbyte>(descriptor);
+    internal static Option<sbyte?> NullableSByte(OptionDescriptor descriptor) => NullableSingle<sbyte?>(descriptor);
+    internal static Option<sbyte[]> SByteArray(OptionDescriptor descriptor) => Multi<sbyte[]>(descriptor);
+    internal static Option<sbyte[]?> NullableSByteArray(OptionDescriptor descriptor) => NullableMulti<sbyte[]?>(descriptor);
+
+    // UShort
+    internal static Option<ushort> UShort(OptionDescriptor descriptor) => Single<ushort>(descriptor);
+    internal static Option<ushort?> NullableUShort(OptionDescriptor descriptor) => NullableSingle<ushort?>(descriptor);
+    internal static Option<ushort[]> UShortArray(OptionDescriptor descriptor) => Multi<ushort[]>(descriptor);
+    internal static Option<ushort[]?> NullableUShortArray(OptionDescriptor descriptor) => NullableMulti<ushort[]?>(descriptor);
+
+    // UInt
+    internal static Option<uint> UInt(OptionDescriptor descriptor) => Single<uint>(descriptor);
+    internal static Option<uint?> NullableUInt(OptionDescriptor descriptor) => NullableSingle<uint?>(descriptor);
+    internal static Option<uint[]> UIntArray(OptionDescriptor descriptor) => Multi<uint[]>(descriptor);
+    internal static Option<uint[]?> NullableUIntArray(OptionDescriptor descriptor) => NullableMulti<uint[]?>(descriptor);
+
+    // ULong
+    internal static Option<ulong> ULong(OptionDescriptor descriptor) => Single<ulong>(descriptor);
+    internal static Option<ulong?> NullableULong(OptionDescriptor descriptor) => NullableSingle<ulong?>(descriptor);
+    internal static Option<ulong[]> ULongArray(OptionDescriptor descriptor) => Multi<ulong[]>(descriptor);
+    internal static Option<ulong[]?> NullableULongArray(OptionDescriptor descriptor) => NullableMulti<ulong[]?>(descriptor);
+
+    // Float
+    internal static Option<float> Float(OptionDescriptor descriptor) => Single<float>(descriptor);
+    internal static Option<float?> NullableFloat(OptionDescriptor descriptor) => NullableSingle<float?>(descriptor);
+    internal static Option<float[]> FloatArray(OptionDescriptor descriptor) => Multi<float[]>(descriptor);
+    internal static Option<float[]?> NullableFloatArray(OptionDescriptor descriptor) => NullableMulti<float[]?>(descriptor);
+
+    // Double
+    internal static Option<double> Double(OptionDescriptor descriptor) => Single<double>(descriptor);
+    internal static Option<double?> NullableDouble(OptionDescriptor descriptor) => NullableSingle<double?>(descriptor);
+    internal static Option<double[]> DoubleArray(OptionDescriptor descriptor) => Multi<double[]>(descriptor);
+    internal static Option<double[]?> NullableDoubleArray(OptionDescriptor descriptor) => NullableMulti<double[]?>(descriptor);
+
+    // Decimal
+    internal static Option<decimal> Decimal(OptionDescriptor descriptor) => Single<decimal>(descriptor);
+    internal static Option<decimal?> NullableDecimal(OptionDescriptor descriptor) => NullableSingle<decimal?>(descriptor);
+    internal static Option<decimal[]> DecimalArray(OptionDescriptor descriptor) => Multi<decimal[]>(descriptor);
+    internal static Option<decimal[]?> NullableDecimalArray(OptionDescriptor descriptor) => NullableMulti<decimal[]?>(descriptor);
+
+    // Char
+    internal static Option<char> Char(OptionDescriptor descriptor) => Single<char>(descriptor);
+    internal static Option<char?> NullableChar(OptionDescriptor descriptor) => NullableSingle<char?>(descriptor);
+    internal static Option<char[]> CharArray(OptionDescriptor descriptor) => Multi<char[]>(descriptor);
+    internal static Option<char[]?> NullableCharArray(OptionDescriptor descriptor) => NullableMulti<char[]?>(descriptor);
+
+    // DateTime
+    internal static Option<DateTime> DateTime(OptionDescriptor descriptor) => Single<DateTime>(descriptor);
+    internal static Option<DateTime?> NullableDateTime(OptionDescriptor descriptor) => NullableSingle<DateTime?>(descriptor);
+    internal static Option<DateTime[]> DateTimeArray(OptionDescriptor descriptor) => Multi<DateTime[]>(descriptor);
+    internal static Option<DateTime[]?> NullableDateTimeArray(OptionDescriptor descriptor) => NullableMulti<DateTime[]?>(descriptor);
+
+    // DateTimeOffset
+    internal static Option<DateTimeOffset> DateTimeOffset(OptionDescriptor descriptor) => Single<DateTimeOffset>(descriptor);
+    internal static Option<DateTimeOffset?> NullableDateTimeOffset(OptionDescriptor descriptor) => NullableSingle<DateTimeOffset?>(descriptor);
+    internal static Option<DateTimeOffset[]> DateTimeOffsetArray(OptionDescriptor descriptor) => Multi<DateTimeOffset[]>(descriptor);
+    internal static Option<DateTimeOffset[]?> NullableDateTimeOffsetArray(OptionDescriptor descriptor) => NullableMulti<DateTimeOffset[]?>(descriptor);
+
+    // TimeSpan
+    internal static Option<TimeSpan> TimeSpan(OptionDescriptor descriptor) => Single<TimeSpan>(descriptor);
+    internal static Option<TimeSpan?> NullableTimeSpan(OptionDescriptor descriptor) => NullableSingle<TimeSpan?>(descriptor);
+    internal static Option<TimeSpan[]> TimeSpanArray(OptionDescriptor descriptor) => Multi<TimeSpan[]>(descriptor);
+    internal static Option<TimeSpan[]?> NullableTimeSpanArray(OptionDescriptor descriptor) => NullableMulti<TimeSpan[]?>(descriptor);
+
+    // Guid
+    internal static Option<Guid> Guid(OptionDescriptor descriptor) => Single<Guid>(descriptor);
+    internal static Option<Guid?> NullableGuid(OptionDescriptor descriptor) => NullableSingle<Guid?>(descriptor);
+    internal static Option<Guid[]> GuidArray(OptionDescriptor descriptor) => Multi<Guid[]>(descriptor);
+    internal static Option<Guid[]?> NullableGuidArray(OptionDescriptor descriptor) => NullableMulti<Guid[]?>(descriptor);
+
+    // Helper methods
+    private static Option<T> Single<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, true, false, ArgumentArity.ExactlyOne);
+    private static Option<T> NullableSingle<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, false, false, ArgumentArity.ZeroOrOne);
+    private static Option<T> Multi<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, true, true, ArgumentArity.OneOrMore);
+    private static Option<T> NullableMulti<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, false, true, ArgumentArity.ZeroOrMore);
+
+    /// <summary>
+    /// Creates a new option of type <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the option.</typeparam>
+    /// <param name="name">The name of the option.</param>
+    /// <param name="aliases">The aliases of the option.</param>
+    /// <param name="description">The description of the option.</param>
+    /// <param name="required">Whether the option is required.</param>
+    /// <param name="allowMultipleArgumentsPerToken">Whether the option allows multiple arguments per token.</param>
+    /// <param name="arity">The arity of the option.</param>
+    /// <returns>The created option.</returns>
+    private static Option<T> CreateOption<T>(
+        OptionDescriptor descriptor,
+        bool required,
+        bool allowMultipleArgumentsPerToken,
+        ArgumentArity arity)
+    {
+        return new Option<T>($"--{descriptor.Name}", descriptor.Aliases.Select(alias => $"--{alias}").ToArray())
+        {
+            Description = descriptor.Description,
+            Required = required,
+            AllowMultipleArgumentsPerToken = allowMultipleArgumentsPerToken,
+            Arity = arity,
+            Hidden = descriptor.Hidden
+        };
+    }
+}
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs b/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
index 0dd8b45194..618f79ed8b 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
@@ -10,7 +10,8 @@ namespace Microsoft.Mcp.Core.Options;
 public class OptionDescriptor
 {
     public required string Name { get; init; }
-    public string? Description { get; init; }
+    public required string Description { get; init; }
+    public string[] Aliases { get; init; } = [];
     public bool Required { get; init; }
     public bool Hidden { get; init; }
     public required PropertyInfo TargetProperty { get; init; }
@@ -51,7 +52,13 @@ private static void CollectDescriptors(Type type, string? prefix, List<OptionDes
                 continue;
             }
 
-            OptionAttribute? optionAttribute = property.GetCustomAttribute<OptionAttribute>();
+            var optionAttribute = property.GetCustomAttribute<OptionAttribute>();
+            // Only support properties with OptionAttribute
+            if (optionAttribute == null)
+            {
+                continue;
+            }
+
             string name = optionAttribute?.Name ?? OptionNameConvention.ToKebabCase(property.Name);
 
             if (!string.IsNullOrEmpty(prefix))
@@ -82,7 +89,7 @@ private static void CollectDescriptors(Type type, string? prefix, List<OptionDes
                 descriptors.Add(new OptionDescriptor
                 {
                     Name = name,
-                    Description = optionAttribute?.Description,
+                    Description = optionAttribute!.Description!,
                     Type = property.PropertyType,
                     Required = !isNullable,
                     Hidden = optionAttribute?.Hidden ?? false,
diff --git a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
index ef1f081906..c8c9547e1f 100644
--- a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
+++ b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
@@ -109,7 +109,7 @@ public void RegisterOptions_String_RegistersCorrectOptions()
     {
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<StringOptions>(command);
+        OptionBinder.RegisterOptions<StringOptions>(command, OptionDescriptor.FromType<StringOptions>());
 
         Assert.Equal(2, command.Options.Count);
         Assert.Contains(command.Options, o => o.Name == "--name");
@@ -121,7 +121,7 @@ public void RegisterOptions_Int_RegistersCorrectOptions()
     {
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<IntOptions>(command);
+        OptionBinder.RegisterOptions<IntOptions>(command, OptionDescriptor.FromType<IntOptions>());
 
         Assert.Equal(2, command.Options.Count);
         Assert.Contains(command.Options, o => o.Name == "--count");
@@ -133,7 +133,7 @@ public void RegisterOptions_Array_SetsArityToOneOrMore()
     {
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<ArrayOptions>(command);
+        OptionBinder.RegisterOptions<ArrayOptions>(command, OptionDescriptor.FromType<ArrayOptions>());
 
         var tagsOption = command.Options.Single(o => o.Name == "--tags");
         Assert.Equal(ArgumentArity.OneOrMore, tagsOption.Arity);
@@ -145,7 +145,7 @@ public void RegisterOptions_Enum_RegistersAsStringOption()
     {
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<EnumOptions>(command);
+        OptionBinder.RegisterOptions<EnumOptions>(command, OptionDescriptor.FromType<EnumOptions>());
 
         Assert.Equal(2, command.Options.Count);
         Assert.Contains(command.Options, o => o.Name == "--color");
@@ -158,7 +158,7 @@ public void RegisterOptions_UnsupportedType_Throws()
         var command = new Command("test");
 
         var ex = Assert.Throws<InvalidOperationException>(
-            () => OptionBinder.RegisterOptions<UnsupportedTypeOptions>(command));
+            () => OptionBinder.RegisterOptions<UnsupportedTypeOptions>(command, OptionDescriptor.FromType<UnsupportedTypeOptions>()));
 
         Assert.Contains("non-scalar element type", ex.Message);
     }
@@ -170,11 +170,12 @@ public void RegisterOptions_UnsupportedType_Throws()
     [Fact]
     public void BindOptions_String_BindsValues()
     {
+        var descriptors = OptionDescriptor.FromType<StringOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<StringOptions>(command);
+        OptionBinder.RegisterOptions<StringOptions>(command, descriptors);
 
         var parseResult = command.Parse("--name hello --description world");
-        var options = OptionBinder.BindOptions<StringOptions>(parseResult);
+        var options = OptionBinder.BindOptions<StringOptions>(parseResult, descriptors);
 
         Assert.Equal("hello", options.Name);
         Assert.Equal("world", options.Description);
@@ -183,11 +184,12 @@ public void BindOptions_String_BindsValues()
     [Fact]
     public void BindOptions_String_NullWhenNotProvided()
     {
+        var descriptors = OptionDescriptor.FromType<StringOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<StringOptions>(command);
+        OptionBinder.RegisterOptions<StringOptions>(command, descriptors);
 
         var parseResult = command.Parse("");
-        var options = OptionBinder.BindOptions<StringOptions>(parseResult);
+        var options = OptionBinder.BindOptions<StringOptions>(parseResult, descriptors);
 
         Assert.Null(options.Name);
         Assert.Null(options.Description);
@@ -196,11 +198,12 @@ public void BindOptions_String_NullWhenNotProvided()
     [Fact]
     public void BindOptions_Int_BindsValues()
     {
+        var descriptors = OptionDescriptor.FromType<IntOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<IntOptions>(command);
+        OptionBinder.RegisterOptions<IntOptions>(command, descriptors);
 
         var parseResult = command.Parse("--count 42 --limit 100");
-        var options = OptionBinder.BindOptions<IntOptions>(parseResult);
+        var options = OptionBinder.BindOptions<IntOptions>(parseResult, descriptors);
 
         Assert.Equal(42, options.Count);
         Assert.Equal(100, options.Limit);
@@ -209,11 +212,12 @@ public void BindOptions_Int_BindsValues()
     [Fact]
     public void BindOptions_Bool_BindsValues()
     {
+        var descriptors = OptionDescriptor.FromType<BoolOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<BoolOptions>(command);
+        OptionBinder.RegisterOptions<BoolOptions>(command, descriptors);
 
         var parseResult = command.Parse("--verbose true --debug false");
-        var options = OptionBinder.BindOptions<BoolOptions>(parseResult);
+        var options = OptionBinder.BindOptions<BoolOptions>(parseResult, descriptors);
 
         Assert.True(options.Verbose);
         Assert.Equal(false, options.Debug);
@@ -222,11 +226,12 @@ public void BindOptions_Bool_BindsValues()
     [Fact]
     public void BindOptions_Array_BindsMultipleValues()
     {
+        var descriptors = OptionDescriptor.FromType<ArrayOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<ArrayOptions>(command);
+        OptionBinder.RegisterOptions<ArrayOptions>(command, descriptors);
 
         var parseResult = command.Parse("--tags foo bar baz --ports 80 443");
-        var options = OptionBinder.BindOptions<ArrayOptions>(parseResult);
+        var options = OptionBinder.BindOptions<ArrayOptions>(parseResult, descriptors);
 
         Assert.Equal(["foo", "bar", "baz"], options.Tags!);
         Assert.Equal([80, 443], options.Ports!);
@@ -235,11 +240,12 @@ public void BindOptions_Array_BindsMultipleValues()
     [Fact]
     public void BindOptions_Enum_BindsCaseInsensitive()
     {
+        var descriptors = OptionDescriptor.FromType<EnumOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<EnumOptions>(command);
+        OptionBinder.RegisterOptions<EnumOptions>(command, descriptors);
 
         var parseResult = command.Parse("--color green --background BLUE");
-        var options = OptionBinder.BindOptions<EnumOptions>(parseResult);
+        var options = OptionBinder.BindOptions<EnumOptions>(parseResult, descriptors);
 
         Assert.Equal(Color.Green, options.Color);
         Assert.Equal(Color.Blue, options.Background);
@@ -248,11 +254,12 @@ public void BindOptions_Enum_BindsCaseInsensitive()
     [Fact]
     public void BindOptions_Enum_MixedCase()
     {
+        var descriptors = OptionDescriptor.FromType<EnumOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<EnumOptions>(command);
+        OptionBinder.RegisterOptions<EnumOptions>(command, descriptors);
 
         var parseResult = command.Parse("--color ReD");
-        var options = OptionBinder.BindOptions<EnumOptions>(parseResult);
+        var options = OptionBinder.BindOptions<EnumOptions>(parseResult, descriptors);
 
         Assert.Equal(Color.Red, options.Color);
     }
@@ -260,11 +267,12 @@ public void BindOptions_Enum_MixedCase()
     [Fact]
     public void BindOptions_NullableEnum_NullWhenNotProvided()
     {
+        var descriptors = OptionDescriptor.FromType<EnumOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<EnumOptions>(command);
+        OptionBinder.RegisterOptions<EnumOptions>(command, descriptors);
 
         var parseResult = command.Parse("--color Red");
-        var options = OptionBinder.BindOptions<EnumOptions>(parseResult);
+        var options = OptionBinder.BindOptions<EnumOptions>(parseResult, descriptors);
 
         Assert.Equal(Color.Red, options.Color);
         Assert.Null(options.Background);
@@ -273,12 +281,13 @@ public void BindOptions_NullableEnum_NullWhenNotProvided()
     [Fact]
     public void BindOptions_Guid_BindsValue()
     {
+        var descriptors = OptionDescriptor.FromType<GuidOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<GuidOptions>(command);
+        OptionBinder.RegisterOptions<GuidOptions>(command, descriptors);
         var guid = Guid.NewGuid();
 
         var parseResult = command.Parse($"--id {guid}");
-        var options = OptionBinder.BindOptions<GuidOptions>(parseResult);
+        var options = OptionBinder.BindOptions<GuidOptions>(parseResult, descriptors);
 
         Assert.Equal(guid, options.Id);
         Assert.Null(options.CorrelationId);
@@ -287,11 +296,12 @@ public void BindOptions_Guid_BindsValue()
     [Fact]
     public void BindOptions_DateTime_BindsValue()
     {
+        var descriptors = OptionDescriptor.FromType<DateTimeOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<DateTimeOptions>(command);
+        OptionBinder.RegisterOptions<DateTimeOptions>(command, descriptors);
 
         var parseResult = command.Parse("--start-date 2024-01-15");
-        var options = OptionBinder.BindOptions<DateTimeOptions>(parseResult);
+        var options = OptionBinder.BindOptions<DateTimeOptions>(parseResult, descriptors);
 
         Assert.Equal(new DateTime(2024, 1, 15), options.StartDate);
     }
@@ -300,11 +310,12 @@ public void BindOptions_DateTime_BindsValue()
     [Fact]
     public void BindOptions_Decimal_BindsValue()
     {
+        var descriptors = OptionDescriptor.FromType<DecimalOptions>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<DecimalOptions>(command);
+        OptionBinder.RegisterOptions<DecimalOptions>(command, descriptors);
 
         var parseResult = command.Parse("--price 19.99 --rate 3.14");
-        var options = OptionBinder.BindOptions<DecimalOptions>(parseResult);
+        var options = OptionBinder.BindOptions<DecimalOptions>(parseResult, descriptors);
 
         Assert.Equal(19.99m, options.Price);
         Assert.Equal(3.14, options.Rate);
@@ -319,7 +330,7 @@ public void RegisterOptions_NestedOptional_FlattenedWithPrefix()
     {
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<NestedOptional>(command);
+        OptionBinder.RegisterOptions<NestedOptional>(command, OptionDescriptor.FromType<NestedOptional>());
 
         // --name, --optional-host, --optional-port, --required-host, --required-port
         Assert.Equal(5, command.Options.Count);
@@ -337,7 +348,7 @@ public void RegisterOptions_NestedOptional_AllChildrenAreOptional()
         // the leaf options remain optional
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<NestedOptional>(command);
+        OptionBinder.RegisterOptions<NestedOptional>(command, OptionDescriptor.FromType<NestedOptional>());
 
         foreach (var option in command.Options)
         {
@@ -348,11 +359,12 @@ public void RegisterOptions_NestedOptional_AllChildrenAreOptional()
     [Fact]
     public void BindOptions_NestedOptional_NullWhenNoChildProvided()
     {
+        var descriptors = OptionDescriptor.FromType<NestedOptional>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<NestedOptional>(command);
+        OptionBinder.RegisterOptions<NestedOptional>(command, descriptors);
 
         var parseResult = command.Parse("--name myapp");
-        var options = OptionBinder.BindOptions<NestedOptional>(parseResult);
+        var options = OptionBinder.BindOptions<NestedOptional>(parseResult, descriptors);
 
         Assert.Equal("myapp", options.Name);
         Assert.Null(options.Optional);
@@ -361,11 +373,12 @@ public void BindOptions_NestedOptional_NullWhenNoChildProvided()
     [Fact]
     public void BindOptions_NestedOptional_BindsOptionalChild()
     {
+        var descriptors = OptionDescriptor.FromType<NestedOptional>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<NestedOptional>(command);
+        OptionBinder.RegisterOptions<NestedOptional>(command, descriptors);
 
         var parseResult = command.Parse("--optional-host localhost --optional-port 8080");
-        var options = OptionBinder.BindOptions<NestedOptional>(parseResult);
+        var options = OptionBinder.BindOptions<NestedOptional>(parseResult, descriptors);
 
         Assert.NotNull(options.Optional);
         Assert.Equal("localhost", options.Optional!.Host);
@@ -375,11 +388,12 @@ public void BindOptions_NestedOptional_BindsOptionalChild()
     [Fact]
     public void BindOptions_NestedOptional_BindsRequiredChild()
     {
+        var descriptors = OptionDescriptor.FromType<NestedOptional>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<NestedOptional>(command);
+        OptionBinder.RegisterOptions<NestedOptional>(command, descriptors);
 
         var parseResult = command.Parse("--required-host 10.0.0.1 --required-port 443");
-        var options = OptionBinder.BindOptions<NestedOptional>(parseResult);
+        var options = OptionBinder.BindOptions<NestedOptional>(parseResult, descriptors);
 
         Assert.NotNull(options.Required);
         Assert.Equal("10.0.0.1", options.Required.Host);
@@ -389,11 +403,12 @@ public void BindOptions_NestedOptional_BindsRequiredChild()
     [Fact]
     public void BindOptions_NestedOptional_PartialChildValues()
     {
+        var descriptors = OptionDescriptor.FromType<NestedOptional>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<NestedOptional>(command);
+        OptionBinder.RegisterOptions<NestedOptional>(command, descriptors);
 
         var parseResult = command.Parse("--optional-host localhost");
-        var options = OptionBinder.BindOptions<NestedOptional>(parseResult);
+        var options = OptionBinder.BindOptions<NestedOptional>(parseResult, descriptors);
 
         Assert.NotNull(options.Optional);
         Assert.Equal("localhost", options.Optional!.Host);
@@ -405,7 +420,7 @@ public void RegisterOptions_NestedRequired_DeepFlattenWithPrefix()
     {
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<NestedRequired>(command);
+        OptionBinder.RegisterOptions<NestedRequired>(command, OptionDescriptor.FromType<NestedRequired>());
 
         // --name, --required-name (required!), --required-port (optional)
         Assert.Equal(3, command.Options.Count);
@@ -420,7 +435,7 @@ public void RegisterOptions_NestedRequired_ScalarChildIsRequired()
         // RequiredNetworkSettings.Name is non-nullable string → required
         var command = new Command("test");
 
-        OptionBinder.RegisterOptions<NestedRequired>(command);
+        OptionBinder.RegisterOptions<NestedRequired>(command, OptionDescriptor.FromType<NestedRequired>());
 
         var requiredName = command.Options.Single(o => o.Name == "--required-name");
         Assert.True(requiredName.Required);
@@ -433,11 +448,12 @@ public void RegisterOptions_NestedRequired_ScalarChildIsRequired()
     [Fact]
     public void BindOptions_NestedRequired_BindsDeepValues()
     {
+        var descriptors = OptionDescriptor.FromType<NestedRequired>();
         var command = new Command("test");
-        OptionBinder.RegisterOptions<NestedRequired>(command);
+        OptionBinder.RegisterOptions<NestedRequired>(command, descriptors);
 
         var parseResult = command.Parse("--name myapp --required-name primary --required-port 5432");
-        var options = OptionBinder.BindOptions<NestedRequired>(parseResult);
+        var options = OptionBinder.BindOptions<NestedRequired>(parseResult, descriptors);
 
         Assert.Equal("myapp", options.Name);
         Assert.NotNull(options.Required);
@@ -492,11 +508,12 @@ public void GetHandler_Enum_ThreadSafe()
         {
             try
             {
+                var descriptors = OptionDescriptor.FromType<EnumOptions>();
                 var command = new Command("test");
-                OptionBinder.RegisterOptions<EnumOptions>(command);
+                OptionBinder.RegisterOptions<EnumOptions>(command, descriptors);
 
                 var parseResult = command.Parse("--color Green");
-                var options = OptionBinder.BindOptions<EnumOptions>(parseResult);
+                var options = OptionBinder.BindOptions<EnumOptions>(parseResult, descriptors);
 
                 Assert.Equal(Color.Green, options.Color);
             }

From aa15b6b6bcdc2ed138b6554836084996c6813145 Mon Sep 17 00:00:00 2001
From: alzimmermsft <48699787+alzimmermsft@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:57:33 -0400
Subject: [PATCH 2/5] Update handling fully

---
 .../src/Extensions/ParseResultExtensions.cs   |   3 +
 .../src/Options/EnumOptionValidator.cs        |  36 --
 .../src/Options/OptionAttribute.cs            |   5 +
 .../src/Options/OptionBinder.cs               | 131 ++-----
 .../src/Options/OptionCreators.cs             | 151 ---------
 .../src/Options/OptionDescriptor.cs           |   2 +-
 .../src/Options/OptionNameConvention.cs       |   5 +-
 .../src/Options/OptionTypeHandler.cs          | 320 ++++++++++++++++++
 .../Options/OptionBinderTests.cs              |  29 +-
 9 files changed, 382 insertions(+), 300 deletions(-)
 delete mode 100644 core/Microsoft.Mcp.Core/src/Options/EnumOptionValidator.cs
 delete mode 100644 core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs
 create mode 100644 core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs

diff --git a/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs b/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
index 7a32c3a461..6304a97143 100644
--- a/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
+++ b/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
@@ -16,6 +16,9 @@ public static bool TryGetValue<T>(this ParseResult parseResult, string optionNam
     public static T? GetValueOrDefault<T>(this ParseResult parseResult, Option<T> option)
         => GetValueOrDefault<T>(parseResult, option.Name);
 
+    public static object? GetValueOrDefault(this ParseResult parseResult, Option option)
+        => GetValueOrDefault<object?>(parseResult, option.Name);
+
     /// <summary>
     /// Gets the value of an option by name, returning default if not found or not set
     /// </summary>
diff --git a/core/Microsoft.Mcp.Core/src/Options/EnumOptionValidator.cs b/core/Microsoft.Mcp.Core/src/Options/EnumOptionValidator.cs
deleted file mode 100644
index 269963c916..0000000000
--- a/core/Microsoft.Mcp.Core/src/Options/EnumOptionValidator.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-using System.CommandLine.Parsing;
-
-namespace Microsoft.Mcp.Core.Options;
-
-/// <summary>
-/// Provides case-insensitive validation and completion for enum options represented as Option&lt;string&gt;.
-/// </summary>
-internal static class EnumOptionValidator
-{
-    /// <summary>
-    /// Configures an option with case-insensitive enum validation and completion sources.
-    /// Mirrors the behavior of AcceptOnlyFromAmong but with case-insensitive matching.
-    /// </summary>
-    public static void Configure(Option<string> option, Type enumType)
-    {
-        var names = Enum.GetNames(enumType);
-        var allowed = string.Join(", ", names);
-        var namesSet = new HashSet<string>(names, StringComparer.OrdinalIgnoreCase);
-
-        option.Validators.Add(result =>
-        {
-            foreach (Token token in result.Tokens)
-            {
-                if (!namesSet.Contains(token.Value))
-                {
-                    result.AddError($"Argument '{token.Value}' not recognized. Must be one of: {allowed}");
-                }
-            }
-        });
-
-        option.CompletionSources.Add(names);
-    }
-}
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs b/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs
index e78538d08d..e1c41a7dba 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs
@@ -40,6 +40,11 @@ public OptionAttribute(string description)
     /// </summary>
     public string? Name { get; init; }
 
+    /// <summary>
+    /// Additional CLI option names (without the "--" prefix).
+    /// </summary>
+    public string[]? Aliases { get; init; }
+
     /// <summary>
     /// A description of what the option controls. Used in help text and by AI agents.
     /// </summary>
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs b/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
index cc0babf168..f7332ec4ec 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
@@ -1,11 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Reflection;
 using Microsoft.Mcp.Core.Commands;
-using Microsoft.Mcp.Core.Extensions;
 
 namespace Microsoft.Mcp.Core.Options;
 
@@ -19,6 +19,8 @@ public static class OptionBinder
         DynamicallyAccessedMemberTypes.PublicProperties |
         DynamicallyAccessedMemberTypes.PublicParameterlessConstructor;
 
+    private static readonly ConcurrentDictionary<Type, OptionTypeHandler[]> s_optionTypeHandlers = new();
+
     /// <summary>
     /// Registers System.CommandLine options on a command based on the public properties of <typeparamref name="TOptions"/>.
     /// </summary>
@@ -27,13 +29,19 @@ public static class OptionBinder
     public static void RegisterOptions<[DynamicallyAccessedMembers(OptionBindingMembers)] TOptions>(Command command, OptionDescriptor[] descriptors)
         where TOptions : class
     {
-        foreach (var descriptor in descriptors)
+        var handlers = s_optionTypeHandlers.GetOrAdd(typeof(TOptions), _ => GetOptionTypeHandlers<TOptions>());
+        foreach (var handler in handlers)
         {
-            var option = CreateOption(descriptor);
-            command.Options.Add(option);
+            command.Options.Add(handler.Option);
         }
     }
 
+    private static OptionTypeHandler[] GetOptionTypeHandlers<[DynamicallyAccessedMembers(OptionBindingMembers)] TOptions>() where TOptions : class
+    {
+        var descriptors = OptionDescriptor.FromType<TOptions>();
+        return [.. descriptors.Select(d => new OptionTypeHandler(d))];
+    }
+
     /// <summary>
     /// Creates a new <typeparamref name="TOptions"/> instance and populates its properties
     /// from the parsed command-line values.
@@ -47,44 +55,43 @@ public static class OptionBinder
         List<string> missingOptions = [];
         List<string> errors = [];
         Dictionary<PropertyInfo, object>? parentInstances = null;
+        var handlers = s_optionTypeHandlers.GetOrAdd(typeof(TOptions), _ => GetOptionTypeHandlers<TOptions>());
 
-        foreach (var descriptor in descriptors)
+        foreach (var handler in handlers)
         {
-            var optionName = $"--{descriptor.Name}";
-
             object? value;
             try
             {
-                value = GetOptionValue(parseResult, descriptor.Type, optionName);
+                value = handler.Binder.Invoke(parseResult);
             }
             catch (Exception ex) when (ex is InvalidOperationException or FormatException or OverflowException or ArgumentException)
             {
-                errors.Add($"Invalid value for '{optionName}': {ex.Message}");
+                errors.Add($"Invalid value for '{handler.Option.Name}': {ex.Message}");
                 continue;
             }
 
             if (value is null)
             {
-                if (descriptor.Required)
+                if (handler.Option.Required)
                 {
-                    missingOptions.Add(optionName);
+                    missingOptions.Add(handler.Option.Name);
                 }
                 continue;
             }
 
-            if (descriptor.ParentProperty is not null)
+            if (handler.Descriptor.ParentProperty is not null)
             {
                 parentInstances ??= [];
-                if (!parentInstances.TryGetValue(descriptor.ParentProperty, out var parent))
+                if (!parentInstances.TryGetValue(handler.Descriptor.ParentProperty, out var parent))
                 {
-                    parent = CreateInstance(descriptor.ParentProperty.PropertyType);
-                    parentInstances[descriptor.ParentProperty] = parent;
+                    parent = CreateInstance(handler.Descriptor.ParentProperty.PropertyType);
+                    parentInstances[handler.Descriptor.ParentProperty] = parent;
                 }
-                descriptor.TargetProperty.SetValue(parent, value);
+                handler.Descriptor.TargetProperty.SetValue(parent, value);
             }
             else
             {
-                descriptor.TargetProperty.SetValue(instance, value);
+                handler.Descriptor.TargetProperty.SetValue(instance, value);
             }
         }
 
@@ -118,87 +125,6 @@ public static class OptionBinder
         return instance;
     }
 
-    private static Option CreateOption(OptionDescriptor descriptor)
-    {
-        var handler = GetHandler(descriptor);
-        var option = handler.CreateOption(descriptor);
-        option.Description = descriptor.Description;
-        option.Required = descriptor.Required;
-        option.Hidden = descriptor.Hidden;
-
-        // For array/collection types, allow multiple values after a single option token
-        // e.g., --modules RedisBloom RedisJSON instead of --modules RedisBloom --modules RedisJSON
-        if (descriptor.Type.IsArray || (descriptor.Type != typeof(string) && descriptor.Type.IsAssignableTo(typeof(System.Collections.IEnumerable))))
-        {
-            option.Arity = ArgumentArity.OneOrMore;
-            option.AllowMultipleArgumentsPerToken = true;
-        }
-
-        return option;
-    }
-
-    private static object? GetOptionValue(ParseResult parseResult, OptionDescriptor descriptor)
-    {
-        var handler = GetHandler<T>(descriptor);
-        return handler.GetValue<T>(parseResult);
-    }
-
-    private static OptionTypeHandler<T> GetHandler<T>(OptionDescriptor descriptor)
-    {
-        if (descriptor.Type == typeof(int))
-        {
-            return new OptionTypeHandler<T>(descriptor, d => OptionCreators.Int(d));
-        }
-        if (s_typeHandlers.TryGetValue(type, out var handler))
-        {
-            return handler;
-        }
-
-        // Enums (and Nullable<enum>): represented as Option<string> with constrained values
-        Type? underlyingEnum = GetUnderlyingEnumType(type);
-        if (underlyingEnum is not null)
-        {
-            return s_typeHandlers.GetOrAdd(type, _ => new OptionTypeHandler(
-                name =>
-                {
-                    var option = new Option<string>(name);
-                    EnumOptionValidator.Configure(option, underlyingEnum);
-                    return option;
-                },
-                (pr, n) =>
-                {
-                    var stringValue = pr.GetValueOrDefault<string>(n);
-
-                    if (stringValue is null)
-                    {
-                        return null;
-                    }
-
-                    return Enum.Parse(underlyingEnum, stringValue, ignoreCase: true);
-                }));
-        }
-
-        throw new InvalidOperationException(
-            $"Unsupported option type '{type}'. Add a handler to s_typeHandlers in OptionBinder, or override RegisterOptions/BindOptions in the command.");
-    }
-
-    private static Type? GetUnderlyingEnumType(Type type)
-    {
-        if (type.IsEnum)
-        {
-            return type;
-        }
-
-        Type? nullable = Nullable.GetUnderlyingType(type);
-
-        if (nullable is not null && nullable.IsEnum)
-        {
-            return nullable;
-        }
-
-        return null;
-    }
-
     [UnconditionalSuppressMessage("Trimming", "IL2067:UnrecognizedReflectionPattern",
         Justification = "Nested option types are rooted by the application via property references.")]
     [UnconditionalSuppressMessage("AOT", "IL3050:RequiresDynamicCode",
@@ -208,13 +134,4 @@ private static object CreateInstance(Type type)
         return Activator.CreateInstance(type)
             ?? throw new InvalidOperationException($"Failed to create instance of nested options type '{type.Name}'. Ensure it has a public parameterless constructor.");
     }
-
-    private sealed class OptionTypeHandler(
-        OptionDescriptor descriptor,
-        Func<OptionDescriptor, Option> createOption)
-    {
-        private readonly Lazy<Option> _option = new(() => createOption(descriptor));
-        public Option CreateOption(OptionDescriptor descriptor) => _option.Value;
-        public object? GetValue(ParseResult parseResult) => parseResult.GetValueOrDefault(_option.Value);
-    }
 }
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs b/core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs
deleted file mode 100644
index 4619a6c714..0000000000
--- a/core/Microsoft.Mcp.Core/src/Options/OptionCreators.cs
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-namespace Microsoft.Mcp.Core.Options;
-
-/// <summary>
-/// A class for creating option instances.
-/// </summary>
-internal static class OptionCreators
-{
-    // String
-    internal static Option<string> String(OptionDescriptor descriptor) => Single<string>(descriptor);
-    internal static Option<string?> NullableString(OptionDescriptor descriptor) => NullableSingle<string?>(descriptor);
-    internal static Option<string[]> StringArray(OptionDescriptor descriptor) => Multi<string[]>(descriptor);
-    internal static Option<string[]?> NullableStringArray(OptionDescriptor descriptor) => NullableMulti<string[]?>(descriptor);
-
-    // Boolean
-    internal static Option<bool> Bool(OptionDescriptor descriptor) => Single<bool>(descriptor);
-    internal static Option<bool?> NullableBool(OptionDescriptor descriptor) => NullableSingle<bool?>(descriptor);
-    internal static Option<bool[]> BoolArray(OptionDescriptor descriptor) => Multi<bool[]>(descriptor);
-    internal static Option<bool[]?> NullableBoolArray(OptionDescriptor descriptor) => NullableMulti<bool[]?>(descriptor);
-
-    // Int
-    internal static Option<int> Int(OptionDescriptor descriptor) => Single<int>(descriptor);
-    internal static Option<int?> NullableInt(OptionDescriptor descriptor) => NullableSingle<int?>(descriptor);
-    internal static Option<int[]> IntArray(OptionDescriptor descriptor) => Multi<int[]>(descriptor);
-    internal static Option<int[]?> NullableIntArray(OptionDescriptor descriptor) => NullableMulti<int[]?>(descriptor);
-
-    // Long
-    internal static Option<long> Long(OptionDescriptor descriptor) => Single<long>(descriptor);
-    internal static Option<long?> NullableLong(OptionDescriptor descriptor) => NullableSingle<long?>(descriptor);
-    internal static Option<long[]> LongArray(OptionDescriptor descriptor) => Multi<long[]>(descriptor);
-    internal static Option<long[]?> NullableLongArray(OptionDescriptor descriptor) => NullableMulti<long[]?>(descriptor);
-
-    // Short
-    internal static Option<short> Short(OptionDescriptor descriptor) => Single<short>(descriptor);
-    internal static Option<short?> NullableShort(OptionDescriptor descriptor) => NullableSingle<short?>(descriptor);
-    internal static Option<short[]> ShortArray(OptionDescriptor descriptor) => Multi<short[]>(descriptor);
-    internal static Option<short[]?> NullableShortArray(OptionDescriptor descriptor) => NullableMulti<short[]?>(descriptor);
-
-    // Byte
-    internal static Option<byte> Byte(OptionDescriptor descriptor) => Single<byte>(descriptor);
-    internal static Option<byte?> NullableByte(OptionDescriptor descriptor) => NullableSingle<byte?>(descriptor);
-    internal static Option<byte[]> ByteArray(OptionDescriptor descriptor) => Multi<byte[]>(descriptor);
-    internal static Option<byte[]?> NullableByteArray(OptionDescriptor descriptor) => NullableMulti<byte[]?>(descriptor);
-
-    // SByte
-    internal static Option<sbyte> SByte(OptionDescriptor descriptor) => Single<sbyte>(descriptor);
-    internal static Option<sbyte?> NullableSByte(OptionDescriptor descriptor) => NullableSingle<sbyte?>(descriptor);
-    internal static Option<sbyte[]> SByteArray(OptionDescriptor descriptor) => Multi<sbyte[]>(descriptor);
-    internal static Option<sbyte[]?> NullableSByteArray(OptionDescriptor descriptor) => NullableMulti<sbyte[]?>(descriptor);
-
-    // UShort
-    internal static Option<ushort> UShort(OptionDescriptor descriptor) => Single<ushort>(descriptor);
-    internal static Option<ushort?> NullableUShort(OptionDescriptor descriptor) => NullableSingle<ushort?>(descriptor);
-    internal static Option<ushort[]> UShortArray(OptionDescriptor descriptor) => Multi<ushort[]>(descriptor);
-    internal static Option<ushort[]?> NullableUShortArray(OptionDescriptor descriptor) => NullableMulti<ushort[]?>(descriptor);
-
-    // UInt
-    internal static Option<uint> UInt(OptionDescriptor descriptor) => Single<uint>(descriptor);
-    internal static Option<uint?> NullableUInt(OptionDescriptor descriptor) => NullableSingle<uint?>(descriptor);
-    internal static Option<uint[]> UIntArray(OptionDescriptor descriptor) => Multi<uint[]>(descriptor);
-    internal static Option<uint[]?> NullableUIntArray(OptionDescriptor descriptor) => NullableMulti<uint[]?>(descriptor);
-
-    // ULong
-    internal static Option<ulong> ULong(OptionDescriptor descriptor) => Single<ulong>(descriptor);
-    internal static Option<ulong?> NullableULong(OptionDescriptor descriptor) => NullableSingle<ulong?>(descriptor);
-    internal static Option<ulong[]> ULongArray(OptionDescriptor descriptor) => Multi<ulong[]>(descriptor);
-    internal static Option<ulong[]?> NullableULongArray(OptionDescriptor descriptor) => NullableMulti<ulong[]?>(descriptor);
-
-    // Float
-    internal static Option<float> Float(OptionDescriptor descriptor) => Single<float>(descriptor);
-    internal static Option<float?> NullableFloat(OptionDescriptor descriptor) => NullableSingle<float?>(descriptor);
-    internal static Option<float[]> FloatArray(OptionDescriptor descriptor) => Multi<float[]>(descriptor);
-    internal static Option<float[]?> NullableFloatArray(OptionDescriptor descriptor) => NullableMulti<float[]?>(descriptor);
-
-    // Double
-    internal static Option<double> Double(OptionDescriptor descriptor) => Single<double>(descriptor);
-    internal static Option<double?> NullableDouble(OptionDescriptor descriptor) => NullableSingle<double?>(descriptor);
-    internal static Option<double[]> DoubleArray(OptionDescriptor descriptor) => Multi<double[]>(descriptor);
-    internal static Option<double[]?> NullableDoubleArray(OptionDescriptor descriptor) => NullableMulti<double[]?>(descriptor);
-
-    // Decimal
-    internal static Option<decimal> Decimal(OptionDescriptor descriptor) => Single<decimal>(descriptor);
-    internal static Option<decimal?> NullableDecimal(OptionDescriptor descriptor) => NullableSingle<decimal?>(descriptor);
-    internal static Option<decimal[]> DecimalArray(OptionDescriptor descriptor) => Multi<decimal[]>(descriptor);
-    internal static Option<decimal[]?> NullableDecimalArray(OptionDescriptor descriptor) => NullableMulti<decimal[]?>(descriptor);
-
-    // Char
-    internal static Option<char> Char(OptionDescriptor descriptor) => Single<char>(descriptor);
-    internal static Option<char?> NullableChar(OptionDescriptor descriptor) => NullableSingle<char?>(descriptor);
-    internal static Option<char[]> CharArray(OptionDescriptor descriptor) => Multi<char[]>(descriptor);
-    internal static Option<char[]?> NullableCharArray(OptionDescriptor descriptor) => NullableMulti<char[]?>(descriptor);
-
-    // DateTime
-    internal static Option<DateTime> DateTime(OptionDescriptor descriptor) => Single<DateTime>(descriptor);
-    internal static Option<DateTime?> NullableDateTime(OptionDescriptor descriptor) => NullableSingle<DateTime?>(descriptor);
-    internal static Option<DateTime[]> DateTimeArray(OptionDescriptor descriptor) => Multi<DateTime[]>(descriptor);
-    internal static Option<DateTime[]?> NullableDateTimeArray(OptionDescriptor descriptor) => NullableMulti<DateTime[]?>(descriptor);
-
-    // DateTimeOffset
-    internal static Option<DateTimeOffset> DateTimeOffset(OptionDescriptor descriptor) => Single<DateTimeOffset>(descriptor);
-    internal static Option<DateTimeOffset?> NullableDateTimeOffset(OptionDescriptor descriptor) => NullableSingle<DateTimeOffset?>(descriptor);
-    internal static Option<DateTimeOffset[]> DateTimeOffsetArray(OptionDescriptor descriptor) => Multi<DateTimeOffset[]>(descriptor);
-    internal static Option<DateTimeOffset[]?> NullableDateTimeOffsetArray(OptionDescriptor descriptor) => NullableMulti<DateTimeOffset[]?>(descriptor);
-
-    // TimeSpan
-    internal static Option<TimeSpan> TimeSpan(OptionDescriptor descriptor) => Single<TimeSpan>(descriptor);
-    internal static Option<TimeSpan?> NullableTimeSpan(OptionDescriptor descriptor) => NullableSingle<TimeSpan?>(descriptor);
-    internal static Option<TimeSpan[]> TimeSpanArray(OptionDescriptor descriptor) => Multi<TimeSpan[]>(descriptor);
-    internal static Option<TimeSpan[]?> NullableTimeSpanArray(OptionDescriptor descriptor) => NullableMulti<TimeSpan[]?>(descriptor);
-
-    // Guid
-    internal static Option<Guid> Guid(OptionDescriptor descriptor) => Single<Guid>(descriptor);
-    internal static Option<Guid?> NullableGuid(OptionDescriptor descriptor) => NullableSingle<Guid?>(descriptor);
-    internal static Option<Guid[]> GuidArray(OptionDescriptor descriptor) => Multi<Guid[]>(descriptor);
-    internal static Option<Guid[]?> NullableGuidArray(OptionDescriptor descriptor) => NullableMulti<Guid[]?>(descriptor);
-
-    // Helper methods
-    private static Option<T> Single<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, true, false, ArgumentArity.ExactlyOne);
-    private static Option<T> NullableSingle<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, false, false, ArgumentArity.ZeroOrOne);
-    private static Option<T> Multi<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, true, true, ArgumentArity.OneOrMore);
-    private static Option<T> NullableMulti<T>(OptionDescriptor descriptor) => CreateOption<T>(descriptor, false, true, ArgumentArity.ZeroOrMore);
-
-    /// <summary>
-    /// Creates a new option of type <typeparamref name="T"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the option.</typeparam>
-    /// <param name="name">The name of the option.</param>
-    /// <param name="aliases">The aliases of the option.</param>
-    /// <param name="description">The description of the option.</param>
-    /// <param name="required">Whether the option is required.</param>
-    /// <param name="allowMultipleArgumentsPerToken">Whether the option allows multiple arguments per token.</param>
-    /// <param name="arity">The arity of the option.</param>
-    /// <returns>The created option.</returns>
-    private static Option<T> CreateOption<T>(
-        OptionDescriptor descriptor,
-        bool required,
-        bool allowMultipleArgumentsPerToken,
-        ArgumentArity arity)
-    {
-        return new Option<T>($"--{descriptor.Name}", descriptor.Aliases.Select(alias => $"--{alias}").ToArray())
-        {
-            Description = descriptor.Description,
-            Required = required,
-            AllowMultipleArgumentsPerToken = allowMultipleArgumentsPerToken,
-            Arity = arity,
-            Hidden = descriptor.Hidden
-        };
-    }
-}
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs b/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
index 618f79ed8b..c6a41cbb5a 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
@@ -3,7 +3,6 @@
 
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
-using Microsoft.Mcp.Core.Commands;
 
 namespace Microsoft.Mcp.Core.Options;
 
@@ -89,6 +88,7 @@ private static void CollectDescriptors(Type type, string? prefix, List<OptionDes
                 descriptors.Add(new OptionDescriptor
                 {
                     Name = name,
+                    Aliases = optionAttribute!.Aliases ?? [],
                     Description = optionAttribute!.Description!,
                     Type = property.PropertyType,
                     Required = !isNullable,
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionNameConvention.cs b/core/Microsoft.Mcp.Core/src/Options/OptionNameConvention.cs
index 34791a4291..bc6aa3a851 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionNameConvention.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionNameConvention.cs
@@ -3,7 +3,7 @@
 
 using System.Text;
 
-namespace Microsoft.Mcp.Core.Commands;
+namespace Microsoft.Mcp.Core.Options;
 
 /// <summary>
 /// Derives CLI option names from C# property names using kebab-case convention.
@@ -63,6 +63,5 @@ public static string ToKebabCase(string propertyName)
     /// <summary>
     /// Returns the full CLI option flag (e.g., "--vault-name") for a property name.
     /// </summary>
-    public static string ToOptionFlag(string propertyName) =>
-        $"--{ToKebabCase(propertyName)}";
+    public static string ToOptionFlag(string propertyName) => $"--{ToKebabCase(propertyName)}";
 }
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
new file mode 100644
index 0000000000..97f6a18b0e
--- /dev/null
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
@@ -0,0 +1,320 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.CommandLine.Parsing;
+using System.Reflection;
+using Microsoft.Mcp.Core.Extensions;
+
+namespace Microsoft.Mcp.Core.Options;
+
+/// <summary>
+/// Handles creating and binding options.
+/// </summary>
+public sealed class OptionTypeHandler
+{
+    public OptionDescriptor Descriptor { get; }
+    public Option Option { get; }
+    public Func<ParseResult, object?> Binder { get; }
+
+    public OptionTypeHandler(OptionDescriptor descriptor)
+    {
+        Descriptor = descriptor;
+        var optionAndBinder = CreateFromDescriptor(descriptor);
+        Option = optionAndBinder.Item1;
+        Binder = optionAndBinder.Item2;
+    }
+
+    internal static (Option, Func<ParseResult, object?>) CreateFromDescriptor(OptionDescriptor descriptor)
+    {
+        var type = descriptor.Type;
+
+        // Check for nullable types, unwrap them and track that they're optional.
+        var isNullable = false;
+        var underlyingType = Nullable.GetUnderlyingType(type);
+        if (underlyingType != null)
+        {
+            type = underlyingType;
+            isNullable = true;
+        }
+        else
+        {
+            var nullabilityInfo = new NullabilityInfoContext().Create(descriptor.TargetProperty);
+            if (nullabilityInfo.WriteState == NullabilityState.Nullable)
+            {
+                type = nullabilityInfo.Type;
+                isNullable = true;
+            }
+        }
+
+        // Check for enumerable types, unwrap them and track that they're multi-valued.
+        var isMulti = false;
+        if (type.IsArray)
+        {
+            type = type.GetElementType()!;
+            isMulti = true;
+        }
+        else if (type != typeof(string) && type.IsAssignableTo(typeof(System.Collections.IEnumerable)))
+        {
+            type = type.GetGenericArguments()[0];
+            isMulti = true;
+        }
+
+        var optionAndBinder = CreateOptionAndBinder(type, isNullable, isMulti, descriptor);
+        if (optionAndBinder is null)
+        {
+            throw new InvalidOperationException($"Unsupported option type '{descriptor.Type}'. Add handling to OptionCreator or use a supported type and handle with PostBindOptions.");
+        }
+
+        var option = optionAndBinder.Value.Item1;
+        option.Description = descriptor.Description;
+        option.Required = descriptor.Required;
+        // For array/collection types, allow multiple values after a single option token
+        // e.g., --modules RedisBloom RedisJSON instead of --modules RedisBloom --modules RedisJSON
+        option.AllowMultipleArgumentsPerToken = isMulti;
+        option.Arity = GetArgumentArity(isNullable, isMulti);
+        option.Hidden = descriptor.Hidden;
+
+        if (type.IsEnum)
+        {
+            // Handle enum options as Option<string> with constrained values.
+            var names = Enum.GetNames(type);
+            var allowed = string.Join(", ", names);
+            var namesSet = new HashSet<string>(names, StringComparer.OrdinalIgnoreCase);
+            option.Validators.Add(result =>
+            {
+                foreach (Token token in result.Tokens)
+                {
+                    if (!namesSet.Contains(token.Value))
+                    {
+                        result.AddError($"Argument '{token.Value}' not recognized. Must be one of: {allowed}");
+                    }
+                }
+            });
+
+            option.CompletionSources.Add(names);
+            Func<ParseResult, object?> enumBinder = parseResult =>
+            {
+                var result = optionAndBinder.Value.Item2.Invoke(parseResult);
+                if (result is string s)
+                {
+                    return Enum.Parse(type, s, ignoreCase: true);
+                }
+                if (result is IEnumerable<string> strings)
+                {
+                    return strings.Select(s => Enum.Parse(type, s, ignoreCase: true)).ToArray();
+                }
+                return result;
+            };
+            return (option, enumBinder);
+        }
+
+        return optionAndBinder.Value;
+    }
+
+    private static (Option, Func<ParseResult, object?>)? CreateOptionAndBinder(
+        Type type,
+        bool isNullable,
+        bool isMulti,
+        OptionDescriptor descriptor)
+    {
+        // Enums are handled as a string with additional binding.
+        if (typeof(string) == type || type.IsEnum)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<string[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<string[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<string?>(descriptor);
+            return CreateOptionAndBinderHelper<string>(descriptor);
+        }
+        if (typeof(bool) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<bool[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<bool[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<bool?>(descriptor);
+            return CreateOptionAndBinderHelper<bool>(descriptor);
+        }
+        if (typeof(int) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<int[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<int[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<int?>(descriptor);
+            return CreateOptionAndBinderHelper<int>(descriptor);
+        }
+        if (typeof(long) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<long[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<long[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<long?>(descriptor);
+            return CreateOptionAndBinderHelper<long>(descriptor);
+        }
+        if (typeof(short) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<short[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<short[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<short?>(descriptor);
+            return CreateOptionAndBinderHelper<short>(descriptor);
+        }
+        if (typeof(byte) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<byte[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<byte[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<byte?>(descriptor);
+            return CreateOptionAndBinderHelper<byte>(descriptor);
+        }
+        if (typeof(sbyte) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<sbyte[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<sbyte[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<sbyte?>(descriptor);
+            return CreateOptionAndBinderHelper<sbyte>(descriptor);
+        }
+        if (typeof(ushort) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<ushort[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<ushort[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<ushort?>(descriptor);
+            return CreateOptionAndBinderHelper<ushort>(descriptor);
+        }
+        if (typeof(uint) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<uint[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<uint[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<uint?>(descriptor);
+            return CreateOptionAndBinderHelper<uint>(descriptor);
+        }
+        if (typeof(ulong) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<ulong[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<ulong[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<ulong?>(descriptor);
+            return CreateOptionAndBinderHelper<ulong>(descriptor);
+        }
+        if (typeof(float) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<float[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<float[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<float?>(descriptor);
+            return CreateOptionAndBinderHelper<float>(descriptor);
+        }
+        if (typeof(double) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<double[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<double[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<double?>(descriptor);
+            return CreateOptionAndBinderHelper<double>(descriptor);
+        }
+        if (typeof(decimal) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<decimal[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<decimal[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<decimal?>(descriptor);
+            return CreateOptionAndBinderHelper<decimal>(descriptor);
+        }
+        if (typeof(char) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<char[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<char[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<char?>(descriptor);
+            return CreateOptionAndBinderHelper<char>(descriptor);
+        }
+        if (typeof(DateTime) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<DateTime[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<DateTime[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<DateTime?>(descriptor);
+            return CreateOptionAndBinderHelper<DateTime>(descriptor);
+        }
+        if (typeof(DateTimeOffset) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<DateTimeOffset[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<DateTimeOffset[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<DateTimeOffset?>(descriptor);
+            return CreateOptionAndBinderHelper<DateTimeOffset>(descriptor);
+        }
+        if (typeof(TimeSpan) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<TimeSpan[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<TimeSpan[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<TimeSpan?>(descriptor);
+            return CreateOptionAndBinderHelper<TimeSpan>(descriptor);
+        }
+        if (typeof(Guid) == type)
+        {
+            if (isNullable && isMulti)
+                return CreateOptionAndBinderHelper<Guid[]?>(descriptor);
+            if (isMulti)
+                return CreateOptionAndBinderHelper<Guid[]>(descriptor);
+            if (isNullable)
+                return CreateOptionAndBinderHelper<Guid?>(descriptor);
+            return CreateOptionAndBinderHelper<Guid>(descriptor);
+        }
+        return null;
+    }
+
+    private static (Option, Func<ParseResult, object?>) CreateOptionAndBinderHelper<T>(OptionDescriptor descriptor)
+    {
+        var option = new Option<T>($"--{descriptor.Name}", [.. descriptor.Aliases.Select(a => $"--{a}")]);
+        return (option, parseResult => parseResult.GetValueOrDefault(option));
+    }
+
+    private static ArgumentArity GetArgumentArity(bool isNullable, bool isMulti)
+    {
+        if (isMulti && isNullable)
+            return ArgumentArity.ZeroOrMore;
+        if (isMulti)
+            return ArgumentArity.OneOrMore;
+        if (isNullable)
+            return ArgumentArity.ZeroOrOne;
+        return ArgumentArity.ExactlyOne;
+    }
+}
diff --git a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
index c8c9547e1f..9f01c9269a 100644
--- a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
+++ b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 using System.CommandLine;
-using System.CommandLine.Parsing;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using Microsoft.Mcp.Core.Commands;
@@ -17,25 +16,33 @@ public sealed class OptionBinderTests
 
     private sealed class StringOptions
     {
+        [Option]
         public string? Name { get; set; }
+        [Option]
         public string? Description { get; set; }
     }
 
     private sealed class IntOptions
     {
+        [Option]
         public int Count { get; set; }
+        [Option]
         public int? Limit { get; set; }
     }
 
     private sealed class BoolOptions
     {
+        [Option]
         public bool Verbose { get; set; }
+        [Option]
         public bool? Debug { get; set; }
     }
 
     private sealed class ArrayOptions
     {
+        [Option]
         public string[]? Tags { get; set; }
+        [Option]
         public int[]? Ports { get; set; }
     }
 
@@ -48,55 +55,73 @@ private enum Color
 
     private sealed class EnumOptions
     {
+        [Option]
         public Color Color { get; set; }
+        [Option]
         public Color? Background { get; set; }
     }
 
     private sealed class GuidOptions
     {
+        [Option]
         public Guid Id { get; set; }
+        [Option]
         public Guid? CorrelationId { get; set; }
     }
 
     private sealed class DateTimeOptions
     {
+        [Option]
         public DateTime StartDate { get; set; }
+        [Option]
         public DateTimeOffset? Timestamp { get; set; }
     }
 
     private sealed class DecimalOptions
     {
+        [Option]
         public decimal Price { get; set; }
+        [Option]
         public double? Rate { get; set; }
     }
 
     private sealed class UnsupportedTypeOptions
     {
+        [Option]
         public object[]? Value { get; set; }
     }
 
     private sealed class NetworkSettings
     {
+        [Option]
         public string? Host { get; set; }
+        [Option]
         public int? Port { get; set; }
     }
 
     private sealed class RequiredNetworkSettings
     {
+        [Option]
         public required string Name { get; set; }
+        [Option]
         public int? Port { get; set; }
     }
 
     private sealed class NestedOptional
     {
+        [Option]
         public string? Name { get; set; }
+        [Option]
         public NetworkSettings? Optional { get; set; }
+        [Option]
         public required NetworkSettings Required { get; set; }
     }
 
     private sealed class NestedRequired
     {
+        [Option]
         public string? Name { get; set; }
+        [Option]
         public required RequiredNetworkSettings Required { get; set; }
     }
 
@@ -136,7 +161,7 @@ public void RegisterOptions_Array_SetsArityToOneOrMore()
         OptionBinder.RegisterOptions<ArrayOptions>(command, OptionDescriptor.FromType<ArrayOptions>());
 
         var tagsOption = command.Options.Single(o => o.Name == "--tags");
-        Assert.Equal(ArgumentArity.OneOrMore, tagsOption.Arity);
+        Assert.Equal(ArgumentArity.ZeroOrMore, tagsOption.Arity);
         Assert.True(tagsOption.AllowMultipleArgumentsPerToken);
     }
 

From 7b76bb60c2478ed4191f386f1ed09e1d85b4e4b5 Mon Sep 17 00:00:00 2001
From: alzimmermsft <48699787+alzimmermsft@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:26:21 -0400
Subject: [PATCH 3/5] Improve binding performance

---
 .../src/Extensions/CommandResultExtensions.cs   | 16 ++++++++++++++++
 .../src/Extensions/ParseResultExtensions.cs     | 17 +++++++++++++++--
 .../src/Options/OptionTypeHandler.cs            |  2 +-
 3 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs b/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs
index 7bf0198802..e4cd7b2c1c 100644
--- a/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs
+++ b/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs
@@ -123,6 +123,22 @@ public static bool TryGetValue<T>(this CommandResult commandResult, string optio
         return GetValueOrDefaultImpl(commandResult, option);
     }
 
+    /// <summary>
+    /// Special version fo GetValueOrDefault for new option binding as the Option is immutable once created.
+    /// <para>
+    /// The name-based lookup was needed as modifying static options to change their requiredness created a new Option
+    /// instance. CommandResult result retrieval uses Option in a Dictionary which performs the lookup using the instance
+    /// refrence as the key for the Dictionary. So, that would break silently and necessitated the name based retrieval.
+    /// That is no longer necessary with the new option binding approach.
+    /// </para>
+    /// </summary>
+    /// <typeparam name="T">The type of the option value</typeparam>
+    /// <param name="commandResult">The command result</param>
+    /// <param name="option">The option</param>
+    /// <returns>The value of the option, or the default value if not found or not set</returns>
+    internal static T? GetValueOrDefaultWithoutName<T>(this CommandResult commandResult, Option<T> option)
+        => GetValueOrDefaultImpl(commandResult, option);
+
     private static T? GetValueOrDefaultImpl<T>(CommandResult commandResult, Option<T> option)
     {
         ArgumentNullException.ThrowIfNull(commandResult);
diff --git a/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs b/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
index 6304a97143..c60dcff160 100644
--- a/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
+++ b/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
@@ -16,8 +16,21 @@ public static bool TryGetValue<T>(this ParseResult parseResult, string optionNam
     public static T? GetValueOrDefault<T>(this ParseResult parseResult, Option<T> option)
         => GetValueOrDefault<T>(parseResult, option.Name);
 
-    public static object? GetValueOrDefault(this ParseResult parseResult, Option option)
-        => GetValueOrDefault<object?>(parseResult, option.Name);
+    /// <summary>
+    /// Special version fo GetValueOrDefault for new option binding as the Option is immutable once created.
+    /// <para>
+    /// The name-based lookup was needed as modifying static options to change their requiredness created a new Option
+    /// instance. ParseResult result retrieval uses Option in a Dictionary which performs the lookup using the instance
+    /// refrence as the key for the Dictionary. So, that would break silently and necessitated the name based retrieval.
+    /// That is no longer necessary with the new option binding approach.
+    /// </para>
+    /// </summary>
+    /// <typeparam name="T">The type of the option value</typeparam>
+    /// <param name="parseResult">The parse result</param>
+    /// <param name="option">The option</param>
+    /// <returns>The value of the option, or the default value if not found or not set</returns>
+    internal static T? GetValueOrDefaultWithoutName<T>(this ParseResult parseResult, Option<T> option)
+        => parseResult.CommandResult.GetValueOrDefaultWithoutName<T>(option);
 
     /// <summary>
     /// Gets the value of an option by name, returning default if not found or not set
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
index 97f6a18b0e..f12d6ca446 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
@@ -304,7 +304,7 @@ private static (Option, Func<ParseResult, object?>)? CreateOptionAndBinder(
     private static (Option, Func<ParseResult, object?>) CreateOptionAndBinderHelper<T>(OptionDescriptor descriptor)
     {
         var option = new Option<T>($"--{descriptor.Name}", [.. descriptor.Aliases.Select(a => $"--{a}")]);
-        return (option, parseResult => parseResult.GetValueOrDefault(option));
+        return (option, parseResult => parseResult.GetValueOrDefaultWithoutName(option));
     }
 
     private static ArgumentArity GetArgumentArity(bool isNullable, bool isMulti)

From 51a0d2d69ed668c25e96d17d82468a07f4388d0b Mon Sep 17 00:00:00 2001
From: alzimmermsft <48699787+alzimmermsft@users.noreply.github.com>
Date: Thu, 18 Jun 2026 16:58:05 -0400
Subject: [PATCH 4/5] PR feedback, more tests, small fixes

---
 .../src/Extensions/CommandResultExtensions.cs |  11 +-
 .../src/Extensions/ParseResultExtensions.cs   |  11 +-
 .../src/Options/OptionBinder.cs               |   1 -
 .../src/Options/OptionTypeHandler.cs          |  17 ++-
 .../Options/OptionBinderTests.cs              | 132 +++++++++++++++++-
 5 files changed, 149 insertions(+), 23 deletions(-)

diff --git a/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs b/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs
index e4cd7b2c1c..3b7e1f1c25 100644
--- a/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs
+++ b/core/Microsoft.Mcp.Core/src/Extensions/CommandResultExtensions.cs
@@ -124,12 +124,13 @@ public static bool TryGetValue<T>(this CommandResult commandResult, string optio
     }
 
     /// <summary>
-    /// Special version fo GetValueOrDefault for new option binding as the Option is immutable once created.
+    /// Special version for GetValueOrDefault for new option binding as the Option is immutable once created.
     /// <para>
-    /// The name-based lookup was needed as modifying static options to change their requiredness created a new Option
-    /// instance. CommandResult result retrieval uses Option in a Dictionary which performs the lookup using the instance
-    /// refrence as the key for the Dictionary. So, that would break silently and necessitated the name based retrieval.
-    /// That is no longer necessary with the new option binding approach.
+    /// The name-based lookup was needed because the static Option would be re-created in RegisterOptions when changing
+    /// requiredness. CommandResult result retrieval uses the Option instance references as a Dictionary key. So,
+    /// changing requiredness in RegisterOptions and using the static Option in BindOptions would break silently and
+    /// necessitated the name based retrieval. That is no longer necessary with the new option binding approach and
+    /// this more performant approach should be used.
     /// </para>
     /// </summary>
     /// <typeparam name="T">The type of the option value</typeparam>
diff --git a/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs b/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
index c60dcff160..15d7584b0e 100644
--- a/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
+++ b/core/Microsoft.Mcp.Core/src/Extensions/ParseResultExtensions.cs
@@ -17,12 +17,13 @@ public static bool TryGetValue<T>(this ParseResult parseResult, string optionNam
         => GetValueOrDefault<T>(parseResult, option.Name);
 
     /// <summary>
-    /// Special version fo GetValueOrDefault for new option binding as the Option is immutable once created.
+    /// Special version for GetValueOrDefault for new option binding as the Option is immutable once created.
     /// <para>
-    /// The name-based lookup was needed as modifying static options to change their requiredness created a new Option
-    /// instance. ParseResult result retrieval uses Option in a Dictionary which performs the lookup using the instance
-    /// refrence as the key for the Dictionary. So, that would break silently and necessitated the name based retrieval.
-    /// That is no longer necessary with the new option binding approach.
+    /// The name-based lookup was needed because the static Option would be re-created in RegisterOptions when changing
+    /// requiredness. ParseResult result retrieval uses the Option instance references as a Dictionary key. So,
+    /// changing requiredness in RegisterOptions and using the static Option in BindOptions would break silently and
+    /// necessitated the name based retrieval. That is no longer necessary with the new option binding approach and
+    /// this more performant approach should be used.
     /// </para>
     /// </summary>
     /// <typeparam name="T">The type of the option value</typeparam>
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs b/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
index e45d34fef1..6591abeb60 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionBinder.cs
@@ -46,7 +46,6 @@ public static class OptionBinder
     /// from the parsed command-line values.
     /// </summary>
     /// <param name="parseResult">The parsed command-line values.</param>
-    /// <param name="descriptors">The option descriptors to bind.</param>
     public static TOptions BindOptions<[DynamicallyAccessedMembers(OptionBindingMembers)] TOptions>(ParseResult parseResult)
         where TOptions : class
     {
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
index f12d6ca446..e64d01447a 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
@@ -53,7 +53,7 @@ internal static (Option, Func<ParseResult, object?>) CreateFromDescriptor(Option
             type = type.GetElementType()!;
             isMulti = true;
         }
-        else if (type != typeof(string) && type.IsAssignableTo(typeof(System.Collections.IEnumerable)))
+        else if (type != typeof(string) && type.IsAssignableTo(typeof(IEnumerable<>)))
         {
             type = type.GetGenericArguments()[0];
             isMulti = true;
@@ -62,7 +62,7 @@ internal static (Option, Func<ParseResult, object?>) CreateFromDescriptor(Option
         var optionAndBinder = CreateOptionAndBinder(type, isNullable, isMulti, descriptor);
         if (optionAndBinder is null)
         {
-            throw new InvalidOperationException($"Unsupported option type '{descriptor.Type}'. Add handling to OptionCreator or use a supported type and handle with PostBindOptions.");
+            throw new InvalidOperationException($"Unsupported option type '{descriptor.Type}'. Add handling to ${nameof(OptionTypeHandler)} or use a supported type and handle with PostBindOptions.");
         }
 
         var option = optionAndBinder.Value.Item1;
@@ -71,7 +71,7 @@ internal static (Option, Func<ParseResult, object?>) CreateFromDescriptor(Option
         // For array/collection types, allow multiple values after a single option token
         // e.g., --modules RedisBloom RedisJSON instead of --modules RedisBloom --modules RedisJSON
         option.AllowMultipleArgumentsPerToken = isMulti;
-        option.Arity = GetArgumentArity(isNullable, isMulti);
+        option.Arity = GetArgumentArity(type, isNullable, isMulti);
         option.Hidden = descriptor.Hidden;
 
         if (type.IsEnum)
@@ -101,7 +101,12 @@ internal static (Option, Func<ParseResult, object?>) CreateFromDescriptor(Option
                 }
                 if (result is IEnumerable<string> strings)
                 {
-                    return strings.Select(s => Enum.Parse(type, s, ignoreCase: true)).ToArray();
+                    var parsed = strings.Select(s => Enum.Parse(type, s, ignoreCase: true)).ToArray();
+#pragma warning disable IL3050 // Enum array creation shouldn't be an AoT issue here.
+                    var array = Array.CreateInstance(type, parsed.Length);
+#pragma warning restore IL3050
+                    Array.Copy(parsed, array, parsed.Length);
+                    return array;
                 }
                 return result;
             };
@@ -307,7 +312,7 @@ private static (Option, Func<ParseResult, object?>) CreateOptionAndBinderHelper<
         return (option, parseResult => parseResult.GetValueOrDefaultWithoutName(option));
     }
 
-    private static ArgumentArity GetArgumentArity(bool isNullable, bool isMulti)
+    private static ArgumentArity GetArgumentArity(Type type, bool isNullable, bool isMulti)
     {
         if (isMulti && isNullable)
             return ArgumentArity.ZeroOrMore;
@@ -315,6 +320,6 @@ private static ArgumentArity GetArgumentArity(bool isNullable, bool isMulti)
             return ArgumentArity.OneOrMore;
         if (isNullable)
             return ArgumentArity.ZeroOrOne;
-        return ArgumentArity.ExactlyOne;
+        return typeof(bool) == type ? ArgumentArity.ZeroOrOne : ArgumentArity.ExactlyOne;
     }
 }
diff --git a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
index c80cc176f5..25ccca12bf 100644
--- a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
+++ b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
@@ -41,9 +41,13 @@ private sealed class BoolOptions
     private sealed class ArrayOptions
     {
         [Option]
-        public string[]? Tags { get; set; }
+        public required string[] Tags { get; set; }
         [Option]
-        public int[]? Ports { get; set; }
+        public required int[] Ports { get; set; }
+        [Option]
+        public string[]? NullableTags { get; set; }
+        [Option]
+        public int[]? NullablePorts { get; set; }
     }
 
     private enum Color
@@ -61,6 +65,14 @@ private sealed class EnumOptions
         public Color? Background { get; set; }
     }
 
+    private sealed class ArrayEnumOptions
+    {
+        [Option]
+        public required Color[] Colors { get; set; }
+        [Option]
+        public Color[]? Backgrounds { get; set; }
+    }
+
     private sealed class GuidOptions
     {
         [Option]
@@ -125,6 +137,14 @@ private sealed class NestedRequired
         public required RequiredNetworkSettings Required { get; set; }
     }
 
+    private sealed class AliasedOptions
+    {
+        [Option(Name = "name", Aliases = ["n", "nm"])]
+        public required string Name { get; set; }
+        [Option(Name = "address", Aliases = ["a", "addr"])]
+        public string? Address { get; set; }
+    }
+
     #endregion
 
     #region RegisterOptions Tests
@@ -154,15 +174,19 @@ public void RegisterOptions_Int_RegistersCorrectOptions()
     }
 
     [Fact]
-    public void RegisterOptions_Array_SetsArityToOneOrMore()
+    public void RegisterOptions_Array_SetsExpectedArity()
     {
         var command = new Command("test");
 
         OptionBinder.RegisterOptions<ArrayOptions>(command);
 
         var tagsOption = command.Options.Single(o => o.Name == "--tags");
-        Assert.Equal(ArgumentArity.ZeroOrMore, tagsOption.Arity);
+        Assert.Equal(ArgumentArity.OneOrMore, tagsOption.Arity);
         Assert.True(tagsOption.AllowMultipleArgumentsPerToken);
+
+        var nullableTagsOption = command.Options.Single(o => o.Name == "--nullable-tags");
+        Assert.Equal(ArgumentArity.ZeroOrMore, nullableTagsOption.Arity);
+        Assert.True(nullableTagsOption.AllowMultipleArgumentsPerToken);
     }
 
     [Fact]
@@ -175,6 +199,22 @@ public void RegisterOptions_Enum_RegistersAsStringOption()
         Assert.Equal(2, command.Options.Count);
         Assert.Contains(command.Options, o => o.Name == "--color");
         Assert.Contains(command.Options, o => o.Name == "--background");
+        Assert.Equal(typeof(string), command.Options.Single(o => o.Name == "--color").ValueType);
+        Assert.Equal(typeof(string), command.Options.Single(o => o.Name == "--background").ValueType);
+    }
+
+    [Fact]
+    public void RegisterOptions_ArrayEnum_RegistersAsStringArrayOption()
+    {
+        var command = new Command("test");
+
+        OptionBinder.RegisterOptions<ArrayEnumOptions>(command);
+
+        Assert.Equal(2, command.Options.Count);
+        Assert.Contains(command.Options, o => o.Name == "--colors");
+        Assert.Contains(command.Options, o => o.Name == "--backgrounds");
+        Assert.Equal(typeof(string[]), command.Options.Single(o => o.Name == "--colors").ValueType);
+        Assert.Equal(typeof(string[]), command.Options.Single(o => o.Name == "--backgrounds").ValueType);
     }
 
     [Fact]
@@ -253,8 +293,10 @@ public void BindOptions_Array_BindsMultipleValues()
         var parseResult = command.Parse("--tags foo bar baz --ports 80 443");
         var options = OptionBinder.BindOptions<ArrayOptions>(parseResult);
 
-        Assert.Equal(["foo", "bar", "baz"], options.Tags!);
-        Assert.Equal([80, 443], options.Ports!);
+        Assert.Equal(["foo", "bar", "baz"], options.Tags);
+        Assert.Equal([80, 443], options.Ports);
+        Assert.Null(options.NullableTags);
+        Assert.Null(options.NullablePorts);
     }
 
     [Fact]
@@ -295,6 +337,55 @@ public void BindOptions_NullableEnum_NullWhenNotProvided()
         Assert.Null(options.Background);
     }
 
+    [Fact]
+    public void BindOptions_ArrayEnum_BindsCaseInsensitive()
+    {
+        var command = new Command("test");
+        OptionBinder.RegisterOptions<ArrayEnumOptions>(command);
+
+        var parseResult = command.Parse("--colors green red --backgrounds BLUE GREEN");
+        var options = OptionBinder.BindOptions<ArrayEnumOptions>(parseResult);
+
+        Assert.Equal(2, options.Colors.Length);
+        Assert.Contains(Color.Green, options.Colors);
+        Assert.Contains(Color.Red, options.Colors);
+
+        Assert.NotNull(options.Backgrounds);
+        Assert.Equal(2, options.Backgrounds.Length);
+        Assert.Contains(Color.Blue, options.Backgrounds);
+        Assert.Contains(Color.Green, options.Backgrounds);
+    }
+
+    [Fact]
+    public void BindOptions_ArrayEnum_MixedCase()
+    {
+        var command = new Command("test");
+        OptionBinder.RegisterOptions<ArrayEnumOptions>(command);
+
+        var parseResult = command.Parse("--colors gREEn ReD");
+        var options = OptionBinder.BindOptions<ArrayEnumOptions>(parseResult);
+
+        Assert.Equal(2, options.Colors.Length);
+        Assert.Contains(Color.Green, options.Colors);
+        Assert.Contains(Color.Red, options.Colors);
+    }
+
+    [Fact]
+    public void BindOptions_NullableArrayEnum_NullWhenNotProvided()
+    {
+        var command = new Command("test");
+        OptionBinder.RegisterOptions<ArrayEnumOptions>(command);
+
+        var parseResult = command.Parse("--colors gREEn Red");
+        var options = OptionBinder.BindOptions<ArrayEnumOptions>(parseResult);
+
+        Assert.Equal(2, options.Colors.Length);
+        Assert.Contains(Color.Green, options.Colors);
+        Assert.Contains(Color.Red, options.Colors);
+
+        Assert.Null(options.Backgrounds);
+    }
+
     [Fact]
     public void BindOptions_Guid_BindsValue()
     {
@@ -335,6 +426,35 @@ public void BindOptions_Decimal_BindsValue()
         Assert.Equal(3.14, options.Rate);
     }
 
+    [Theory]
+    [InlineData("name", null)]
+    [InlineData("n", null)]
+    [InlineData("nm", null)]
+    [InlineData("name", "address")]
+    [InlineData("n", "a")]
+    [InlineData("nm", "addr")]
+    public void BindOptions_Aliases_BindsValue(string nameArgName, string? addressArgName)
+    {
+        var command = new Command("test");
+        OptionBinder.RegisterOptions<AliasedOptions>(command);
+
+        var args = new List<string> { $"--{nameArgName}", "John" };
+        if (addressArgName != null)
+        {
+            args.AddRange([$"--{addressArgName}", "Seattle"]);
+        }
+
+        var parseResult = command.Parse(args);
+        var options = OptionBinder.BindOptions<AliasedOptions>(parseResult);
+
+        Assert.Equal("John", options.Name);
+        if (addressArgName != null)
+        {
+            Assert.Equal("Seattle", options.Address);
+
+        }
+    }
+
     #endregion
 
     #region Nested Options Tests

From d05deb7536434b5df2fec1a6f24e9c0e75b216e7 Mon Sep 17 00:00:00 2001
From: alzimmermsft <48699787+alzimmermsft@users.noreply.github.com>
Date: Fri, 19 Jun 2026 18:00:47 -0400
Subject: [PATCH 5/5] Add support for DefaultValue

---
 .../src/Options/OptionAttribute.cs            |  5 +++++
 .../src/Options/OptionDescriptor.cs           |  2 ++
 .../src/Options/OptionTypeHandler.cs          |  4 ++++
 .../Options/OptionBinderTests.cs              | 22 ++++++++++++++++++-
 4 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs b/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs
index e1c41a7dba..5d96f8d662 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionAttribute.cs
@@ -50,6 +50,11 @@ public OptionAttribute(string description)
     /// </summary>
     public string? Description { get; init; }
 
+    /// <summary>
+    /// A default value for the option when a value is not provided. Must match the property type being attributed.
+    /// </summary>
+    public object? DefaultValue { get; init; }
+
     /// <summary>
     /// Whether the option is hidden from help output.
     /// </summary>
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs b/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
index f27fc7cecb..d63ba6b3b6 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionDescriptor.cs
@@ -14,6 +14,7 @@ public class OptionDescriptor
     public string[] Aliases { get; init; } = [];
     public bool Required { get; init; }
     public bool Hidden { get; init; }
+    public object? DefaultValue { get; init; }
     public required PropertyInfo TargetProperty { get; init; }
     public required Type Type { get; init; }
     public PropertyInfo? ParentProperty { get; init; }
@@ -91,6 +92,7 @@ private static void CollectDescriptors(Type type, string? prefix, List<OptionDes
                     Type = property.PropertyType,
                     Required = required,
                     Hidden = optionAttribute?.Hidden ?? false,
+                    DefaultValue = optionAttribute?.DefaultValue,
                     TargetProperty = property,
                     ParentProperty = parentProperty
                 });
diff --git a/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
index e64d01447a..b9f91b79a4 100644
--- a/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
+++ b/core/Microsoft.Mcp.Core/src/Options/OptionTypeHandler.cs
@@ -309,6 +309,10 @@ private static (Option, Func<ParseResult, object?>)? CreateOptionAndBinder(
     private static (Option, Func<ParseResult, object?>) CreateOptionAndBinderHelper<T>(OptionDescriptor descriptor)
     {
         var option = new Option<T>($"--{descriptor.Name}", [.. descriptor.Aliases.Select(a => $"--{a}")]);
+        if (descriptor.DefaultValue != null)
+        {
+            option.DefaultValueFactory = _ => (T)descriptor.DefaultValue;
+        }
         return (option, parseResult => parseResult.GetValueOrDefaultWithoutName(option));
     }
 
diff --git a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
index 25ccca12bf..efe6d7aed4 100644
--- a/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
+++ b/core/Microsoft.Mcp.Core/tests/Microsoft.Mcp.Core.Tests/Options/OptionBinderTests.cs
@@ -145,6 +145,14 @@ private sealed class AliasedOptions
         public string? Address { get; set; }
     }
 
+    private sealed class DefaultedOptions
+    {
+        [Option(DefaultValue = "default")]
+        public string? Name { get; set; }
+        [Option(DefaultValue = 42)]
+        public int? Count { get; set; }
+    }
+
     #endregion
 
     #region RegisterOptions Tests
@@ -451,10 +459,22 @@ public void BindOptions_Aliases_BindsValue(string nameArgName, string? addressAr
         if (addressArgName != null)
         {
             Assert.Equal("Seattle", options.Address);
-
         }
     }
 
+    [Fact]
+    public void BindOptions_DefaultValue_BindsDefault()
+    {
+        var command = new Command("test");
+        OptionBinder.RegisterOptions<DefaultedOptions>(command);
+
+        var parseResult = command.Parse("");
+        var options = OptionBinder.BindOptions<DefaultedOptions>(parseResult);
+
+        Assert.Equal("default", options.Name);
+        Assert.Equal(42, options.Count);
+    }
+
     #endregion
 
     #region Nested Options Tests