Move AIFunctionFactory down to M.E.AI.Abstractions (#6412)

* Remove AIFunctionFactory dependency on M.E.DI

This means reverting the recent changes to it that:
- Special-cased KeyedServices
- Special-cased IServiceProviderIsService
- Used ActivatorUtilities.CreateInstance

* Move AIFunctionFactory down to M.E.AI.Abstractions

* Add CreateInstance delegate to AIFunctionFactoryOptions

To enable use of ActivatorUtilities.CreateInstance or alternative.

* Add some comments

Author: stephentoub

src/Libraries/Microsoft.Extensions.AI.Abstractions/Functions/AIFunctionFactory.cs

@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 #if !NET
 using System.Linq;
@@ -25,7 +26,6 @@
 #pragma warning disable CA1031 // Do not catch general exception types
 #pragma warning disable S2333 // Redundant modifiers should not be used
 #pragma warning disable S3011 // Reflection should not be used to increase accessibility of classes, methods, or fields
-#pragma warning disable SA1202 // Public members should come before private members
 
 namespace Microsoft.Extensions.AI;
 
@@ -373,15 +373,16 @@ public static AIFunction Create(MethodInfo method, object? target, string? name
     }
 
     /// <summary>
-    /// Creates an <see cref="AIFunction"/> instance for a method, specified via a <see cref="MethodInfo"/> for
-    /// an instance method and a <see cref="Func{AIFunctionArguments,Object}"/> for constructing an instance of
-    /// the receiver object each time the <see cref="AIFunction"/> is invoked.
+    /// Creates an <see cref="AIFunction"/> instance for a method, specified via an <see cref="MethodInfo"/> for
+    /// and instance method, along with a <see cref="Type"/> representing the type of the target object to
+    /// instantiate each time the method is invoked.
     /// </summary>
     /// <param name="method">The instance method to be represented via the created <see cref="AIFunction"/>.</param>
-    /// <param name="createInstanceFunc">
-    /// Callback used on each function invocation to create an instance of the type on which the instance method <paramref name="method"/>
-    /// will be invoked. If the returned instance is <see cref="IAsyncDisposable"/> or <see cref="IDisposable"/>, it will be disposed of
-    /// after <paramref name="method"/> completes its invocation.
+    /// <param name="targetType">
+    /// The <see cref="Type"/> to construct an instance of on which to invoke <paramref name="method"/> when
+    /// the resulting <see cref="AIFunction"/> is invoked. <see cref="Activator.CreateInstance(Type)"/> is used,
+    /// utilizing the type's public parameterless constructor. If an instance can't be constructed, an exception is
+    /// thrown during the function's invocation.
     /// </param>
     /// <param name="options">Metadata to use to override defaults inferred from <paramref name="method"/>.</param>
     /// <returns>The created <see cref="AIFunction"/> for invoking <paramref name="method"/>.</returns>
@@ -455,16 +456,22 @@ public static AIFunction Create(MethodInfo method, object? target, string? name
     /// </para>
     /// </remarks>
     /// <exception cref="ArgumentNullException"><paramref name="method"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentNullException"><paramref name="createInstanceFunc"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="targetType"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="method"/> represents a static method.</exception>
     /// <exception cref="ArgumentException"><paramref name="method"/> represents an open generic method.</exception>
     /// <exception cref="ArgumentException"><paramref name="method"/> contains a parameter without a parameter name.</exception>
+    /// <exception cref="ArgumentException"><paramref name="targetType"/> is not assignable to <paramref name="method"/>'s declaring type.</exception>
     /// <exception cref="JsonException">A parameter to <paramref name="method"/> or its return type is not serializable.</exception>
     public static AIFunction Create(
         MethodInfo method,
-        Func<AIFunctionArguments, object> createInstanceFunc,
-        AIFunctionFactoryOptions? options = null) =>
-        ReflectionAIFunction.Build(method, createInstanceFunc, options ?? _defaultOptions);
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type targetType,
+        AIFunctionFactoryOptions? options = null)
+    {
+        _ = Throw.IfNull(method);
+        _ = Throw.IfNull(targetType);
+
+        return ReflectionAIFunction.Build(method, targetType, options ?? _defaultOptions);
+    }
 
     private sealed class ReflectionAIFunction : AIFunction
     {
@@ -495,11 +502,10 @@ public static ReflectionAIFunction Build(MethodInfo method, object? target, AIFu
 
         public static ReflectionAIFunction Build(
             MethodInfo method,
-            Func<AIFunctionArguments, object> createInstanceFunc,
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type targetType,
             AIFunctionFactoryOptions options)
         {
             _ = Throw.IfNull(method);
-            _ = Throw.IfNull(createInstanceFunc);
 
             if (method.ContainsGenericParameters)
             {
@@ -511,7 +517,13 @@ public static ReflectionAIFunction Build(
                 Throw.ArgumentException(nameof(method), "The method must be an instance method.");
             }
 
-            return new(ReflectionAIFunctionDescriptor.GetOrCreate(method, options), createInstanceFunc, options);
+            if (method.DeclaringType is { } declaringType &&
+                !declaringType.IsAssignableFrom(targetType))
+            {
+                Throw.ArgumentException(nameof(targetType), "The target type must be assignable to the method's declaring type.");
+            }
+
+            return new(ReflectionAIFunctionDescriptor.GetOrCreate(method, options), targetType, options);
         }
 
         private ReflectionAIFunction(ReflectionAIFunctionDescriptor functionDescriptor, object? target, AIFunctionFactoryOptions options)
@@ -523,17 +535,20 @@ private ReflectionAIFunction(ReflectionAIFunctionDescriptor functionDescriptor,
 
         private ReflectionAIFunction(
             ReflectionAIFunctionDescriptor functionDescriptor,
-            Func<AIFunctionArguments, object> createInstanceFunc,
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type targetType,
             AIFunctionFactoryOptions options)
         {
             FunctionDescriptor = functionDescriptor;
-            CreateInstanceFunc = createInstanceFunc;
+            TargetType = targetType;
+            CreateInstance = options.CreateInstance;
             AdditionalProperties = options.AdditionalProperties ?? EmptyReadOnlyDictionary<string, object?>.Instance;
         }
 
         public ReflectionAIFunctionDescriptor FunctionDescriptor { get; }
         public object? Target { get; }
-        public Func<AIFunctionArguments, object>? CreateInstanceFunc { get; }
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
+        public Type? TargetType { get; }
+        public Func<Type, AIFunctionArguments, object>? CreateInstance { get; }
 
         public override IReadOnlyDictionary<string, object?> AdditionalProperties { get; }
         public override string Name => FunctionDescriptor.Name;
@@ -550,12 +565,14 @@ private ReflectionAIFunction(
             object? target = Target;
             try
             {
-                if (CreateInstanceFunc is { } func)
+                if (TargetType is { } targetType)
                 {
                     Debug.Assert(target is null, "Expected target to be null when we have a non-null target type");
                     Debug.Assert(!FunctionDescriptor.Method.IsStatic, "Expected an instance method");
 
-                    target = func(arguments);
+                    target = CreateInstance is not null ?
+                        CreateInstance(targetType, arguments) :
+                        Activator.CreateInstance(targetType);
                     if (target is null)
                     {
                         Throw.InvalidOperationException("Unable to create an instance of the target type.");
@@ -1088,34 +1105,6 @@ public override void Flush()
         {
         }
 
-        public override Task FlushAsync(CancellationToken cancellationToken) =>
-            Task.CompletedTask;
-
-        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
-            WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
-
-#if NET
-        public override
-#else
-        private
-#endif
-        ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
-        {
-            EnsureNotDisposed();
-
-            if (cancellationToken.IsCancellationRequested)
-            {
-                return new ValueTask(Task.FromCanceled(cancellationToken));
-            }
-
-            EnsureCapacity(_position + buffer.Length);
-
-            buffer.Span.CopyTo(_buffer.AsSpan(_position));
-            _position += buffer.Length;
-
-            return default;
-        }
-
         public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
         public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
         public override void SetLength(long value) => throw new NotSupportedException();

src/Libraries/Microsoft.Extensions.AI.Abstractions/Functions/AIFunctionFactoryOptions.cs

@@ -106,6 +106,24 @@ public AIFunctionFactoryOptions()
     /// </remarks>
     public Func<object?, Type?, CancellationToken, ValueTask<object?>>? MarshalResult { get; set; }
 
+    /// <summary>
+    /// Gets or sets a delegate used with <see cref="AIFunctionFactory.Create(MethodInfo, Type, AIFunctionFactoryOptions?)"/> to create the receiver instance.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <see cref="AIFunctionFactory.Create(MethodInfo, Type, AIFunctionFactoryOptions?)"/> creates <see cref="AIFunction"/> instances that invoke an
+    /// instance method on the specified <see cref="Type"/>. This delegate is used to create the instance of the type that will be used to invoke the method.
+    /// By default if <see cref="CreateInstance"/> is <see langword="null"/>, <see cref="Activator.CreateInstance(Type)"/> is used. If
+    /// <see cref="CreateInstance"/> is non-<see langword="null"/>, the delegate is invoked with the <see cref="Type"/> to be instantiated and the
+    /// <see cref="AIFunctionArguments"/> provided to the <see cref="AIFunction.InvokeAsync"/> method.
+    /// </para>
+    /// <para>
+    /// Each created instance will be used for a single invocation. If the object is <see cref="IAsyncDisposable"/> or <see cref="IDisposable"/>, it will
+    /// be disposed of after the invocation completes.
+    /// </para>
+    /// </remarks>
+    public Func<Type, AIFunctionArguments, object>? CreateInstance { get; set; }
+
     /// <summary>Provides configuration options produced by the <see cref="ConfigureParameterBinding"/> delegate.</summary>
     public readonly record struct ParameterBindingOptions
     {

test/Libraries/Microsoft.Extensions.AI.Tests/Functions/AIFunctionFactoryTest.cs

@@ -29,8 +29,7 @@ public void InvalidArguments_Throw()
         Assert.Throws<ArgumentNullException>("method", () => AIFunctionFactory.Create(method: null!, target: new object()));
         Assert.Throws<ArgumentNullException>("method", () => AIFunctionFactory.Create(method: null!, target: new object(), name: "myAiFunk"));
         Assert.Throws<ArgumentNullException>("target", () => AIFunctionFactory.Create(typeof(AIFunctionFactoryTest).GetMethod(nameof(InvalidArguments_Throw))!, (object?)null));
-        Assert.Throws<ArgumentNullException>("createInstanceFunc", () =>
-            AIFunctionFactory.Create(typeof(AIFunctionFactoryTest).GetMethod(nameof(InvalidArguments_Throw))!, (Func<AIFunctionArguments, object>)null!));
+        Assert.Throws<ArgumentNullException>("targetType", () => AIFunctionFactory.Create(typeof(AIFunctionFactoryTest).GetMethod(nameof(InvalidArguments_Throw))!, (Type)null!));
         Assert.Throws<ArgumentException>("method", () => AIFunctionFactory.Create(typeof(List<>).GetMethod("Add")!, new List<int>()));
     }
 
@@ -313,12 +312,16 @@ public async Task Create_NoInstance_UsesActivatorUtilitiesWhenServicesAvailable(
 
         AIFunction func = AIFunctionFactory.Create(
             typeof(MyFunctionTypeWithOneArg).GetMethod(nameof(MyFunctionTypeWithOneArg.InstanceMethod))!,
-            static arguments =>
+            typeof(MyFunctionTypeWithOneArg),
+            new()
             {
-                Assert.NotNull(arguments.Services);
-                return ActivatorUtilities.CreateInstance(arguments.Services, typeof(MyFunctionTypeWithOneArg));
-            },
-            new() { MarshalResult = (result, type, cancellationToken) => new ValueTask<object?>(result) });
+                CreateInstance = (type, arguments) =>
+                {
+                    Assert.NotNull(arguments.Services);
+                    return ActivatorUtilities.CreateInstance(arguments.Services, type);
+                },
+                MarshalResult = (result, type, cancellationToken) => new ValueTask<object?>(result),
+            });
 
         Assert.NotNull(func);
         var result = (Tuple<MyFunctionTypeWithOneArg, MyArgumentType>?)await func.InvokeAsync(new() { Services = sp });
@@ -327,41 +330,55 @@ public async Task Create_NoInstance_UsesActivatorUtilitiesWhenServicesAvailable(
     }
 
     [Fact]
-    public async Task Create_CreateInstanceReturnsNull_ThrowsDuringInvocation()
+    public async Task Create_NoInstance_UsesActivatorWhenServicesUnavailable()
     {
         AIFunction func = AIFunctionFactory.Create(
-            typeof(MyFunctionTypeWithOneArg).GetMethod(nameof(MyFunctionTypeWithOneArg.InstanceMethod))!,
-            static _ => null!);
+            typeof(MyFunctionTypeWithNoArgs).GetMethod(nameof(MyFunctionTypeWithNoArgs.InstanceMethod))!,
+            typeof(MyFunctionTypeWithNoArgs),
+            new()
+            {
+                MarshalResult = (result, type, cancellationToken) => new ValueTask<object?>(result),
+            });
 
         Assert.NotNull(func);
-        await Assert.ThrowsAsync<InvalidOperationException>(async () => await func.InvokeAsync());
+        Assert.Equal("42", await func.InvokeAsync());
     }
 
     [Fact]
-    public async Task Create_WrongConstructedType_ThrowsDuringInvocation()
+    public async Task Create_NoInstance_ThrowsWhenCantConstructInstance()
     {
+        var sp = new ServiceCollection().BuildServiceProvider();
+
         AIFunction func = AIFunctionFactory.Create(
             typeof(MyFunctionTypeWithOneArg).GetMethod(nameof(MyFunctionTypeWithOneArg.InstanceMethod))!,
-            static _ => new MyFunctionTypeWithNoArgs());
+            typeof(MyFunctionTypeWithOneArg));
 
         Assert.NotNull(func);
-        await Assert.ThrowsAsync<TargetException>(async () => await func.InvokeAsync());
+        await Assert.ThrowsAsync<MissingMethodException>(async () => await func.InvokeAsync(new() { Services = sp }));
     }
 
     [Fact]
     public void Create_NoInstance_ThrowsForStaticMethod()
     {
         Assert.Throws<ArgumentException>("method", () => AIFunctionFactory.Create(
             typeof(MyFunctionTypeWithNoArgs).GetMethod(nameof(MyFunctionTypeWithNoArgs.StaticMethod))!,
-            static _ => new MyFunctionTypeWithNoArgs()));
+            typeof(MyFunctionTypeWithNoArgs)));
+    }
+
+    [Fact]
+    public void Create_NoInstance_ThrowsForMismatchedMethod()
+    {
+        Assert.Throws<ArgumentException>("targetType", () => AIFunctionFactory.Create(
+            typeof(MyFunctionTypeWithNoArgs).GetMethod(nameof(MyFunctionTypeWithNoArgs.InstanceMethod))!,
+            typeof(MyFunctionTypeWithOneArg)));
     }
 
     [Fact]
     public async Task Create_NoInstance_DisposableInstanceCreatedDisposedEachInvocation()
     {
         AIFunction func = AIFunctionFactory.Create(
             typeof(DisposableService).GetMethod(nameof(DisposableService.GetThis))!,
-            static _ => new DisposableService(),
+            typeof(DisposableService),
             new()
             {
                 MarshalResult = (result, type, cancellationToken) => new ValueTask<object?>(result),
@@ -380,7 +397,7 @@ public async Task Create_NoInstance_AsyncDisposableInstanceCreatedDisposedEachIn
     {
         AIFunction func = AIFunctionFactory.Create(
             typeof(AsyncDisposableService).GetMethod(nameof(AsyncDisposableService.GetThis))!,
-            static _ => new AsyncDisposableService(),
+            typeof(AsyncDisposableService),
             new()
             {
                 MarshalResult = (result, type, cancellationToken) => new ValueTask<object?>(result),
@@ -399,7 +416,7 @@ public async Task Create_NoInstance_DisposableAndAsyncDisposableInstanceCreatedD
     {
         AIFunction func = AIFunctionFactory.Create(
             typeof(DisposableAndAsyncDisposableService).GetMethod(nameof(DisposableAndAsyncDisposableService.GetThis))!,
-            static _ => new DisposableAndAsyncDisposableService(),
+            typeof(DisposableAndAsyncDisposableService),
             new()
             {
                 MarshalResult = (result, type, cancellationToken) => new ValueTask<object?>(result),
@@ -804,7 +821,11 @@ public ValueTask DisposeAsync()
 
     private sealed class MyFunctionTypeWithNoArgs
     {
+        private string _value = "42";
+
         public static void StaticMethod() => throw new NotSupportedException();
+
+        public string InstanceMethod() => _value;
     }
 
     private sealed class MyFunctionTypeWithOneArg(MyArgumentType arg)