Samples in c# of how tools from classes like in Semantic Kernel

[christianarg]

I've checked your samples and Semantic Kernel Migration guide and there are no samples on how to add tools when methods are defined in a class. All your samples use top level statement but most apps are not just a Program.cs

Also a small helper to add all methods in a plugin class as tools would be useful to the migration from your previous oficial AI Library until 2 days ago.

[stephentoub]

Also a small helper to add all methods in a plugin class as tools

There are lots of ways, all customizable. For example, if you wanted to add all instance and static from a particular type, you can have a method somewhere in your project with the desired semantics, e.g.

static IEnumerable<AITool> GetTools<T>(T instance) =>
    from m in typeof(T).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly)
    select AIFunctionFactory.Create(m, instance);

or if you wanted a type to itself expose what should be used, possibly with dynamism to control which tools are provided based on conditions, e.g.

class Test
{
    public string Echo(string input) => input;
    public static int Add(int a, int b) => a + b;

    public IEnumerable<AITool> GetTools()
    {
        yield return AIFunctionFactory.Create(Echo);
        if (Environment.ProcessorCount > 4)
        {
            yield return AIFunctionFactory.Create(Add);
        }
    }
}

Etc.

[christianarg]

yeah I assumed it would be something like this. Just asking if there was some kind of recommended way.
I also assume that we have to manually handle DI however we want? In SK Plugins had built in DI

public class MyPlugin(IMyService someService)
{
      [KernelFunction]
      public string SomeFunction() => someService.SomeMethod();
}

and while service locator it's not generally recommended... it's probably at least for now what we have to do with Microsoft Agent Service?

With your GetTools method, if we want DI it would be something like this?

var tools = GetTools(services.GetRequiredService<SomeYeOldeSKPlugin>())

AIAgent agent = chatClient.CreateAIAgent(tools: tools);

(yes I also could define a class to inject by constructor all the plugins I need I guess..)

Again, just asking in case there is some other better way. If this is how it is, we'll deal with it.

[jooooel]

Yes, +1 on the usage of tools with DI. Trying to migrate from SK where we have a lot of tools like these

[Description("Plugin for...")]
public class MyPlugin(
    ILogger<MyPlugin> logger,
    DataContext dataContext)
{
    [KernelFunction("find_data")]
    [Description("Searches for data")]
    public async Task<string> FindDataAsync(
        Kernel kernel,
        DataSearchQuery query,
        CancellationToken cancellationToken)
    {
        var accountId = kernel.GetAccountId();
        var data = await dataContext.DataItems
            .Where(d => d.AccountId == accountId && d.Content.Contains(query.SearchTerm))
            .ToListAsync(cancellationToken);
        ...
    }
}

[stephentoub]

100% untested, but you could add something like this to your project, tweaked with whatever customization you want.

using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using System.Reflection;
using System.Runtime.CompilerServices;

namespace Microsoft.Agents.AI;

public interface IToolProvider
{
    IEnumerable<AITool> GetTools();
}

public static class ToolProvider
{
    public static ChatClientBuilder UseToolProviders(this ChatClientBuilder builder) =>
        builder.Use((innerClient, services) => services is null ? innerClient : new ToolProviderChatClient(innerClient, services));

    private sealed class ToolProviderChatClient(IChatClient innerClient, IServiceProvider services) : DelegatingChatClient(innerClient)
    {
        public override async Task<ChatResponse> GetResponseAsync(
            IEnumerable<ChatMessage> messages, ChatOptions? options = null, CancellationToken cancellationToken = default) =>
            await base.GetResponseAsync(messages, Configure(options), cancellationToken);

        public override async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
            IEnumerable<ChatMessage> messages, ChatOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
        {
            await foreach (var update in base.GetStreamingResponseAsync(messages, Configure(options), cancellationToken))
                yield return update;
        }

        private ChatOptions Configure(ChatOptions? options)
        {
            options = options?.Clone() ?? new();

            options.Tools ??= [];
            if (services.GetService<IEnumerable<IToolProvider>>() is { } toolProviders)
            {
                foreach (AITool tool in toolProviders.SelectMany(tp => tp.GetTools()))
                {
                    options.Tools.Add(tool);
                }
            }

            return options;
        }
    }

    public static IToolProvider CreateFromType<T>(IServiceProvider? services = null) where T : class
    {
        AIFunctionFactoryOptions options = new()
        {
            ConfigureParameterBinding = pi =>
            {
                if (services?.GetService<IServiceProviderIsService>() is { } ispis && ispis.IsService(pi.ParameterType))
                {
                    return new()
                    {
                        ExcludeFromSchema = true,
                        BindParameter = (pi, args) => args.Services?.GetService(pi.ParameterType) ?? DefaultOrThrow(pi),
                    };
                }

                if (pi.GetCustomAttribute<FromKeyedServicesAttribute>() is { } keyedAttr)
                {
                    return new()
                    {
                        ExcludeFromSchema = true,
                        BindParameter = (pi, args) => (args?.Services as IKeyedServiceProvider)?.GetKeyedService(pi.ParameterType, keyedAttr.Key) ?? DefaultOrThrow(pi),
                    };
                }

                return default;

                static object? DefaultOrThrow(ParameterInfo pi) => pi.HasDefaultValue ? null : throw new ArgumentException("No service of the requested type was found.");
            },
        };

        List<AIFunction> functions =
            (from m in typeof(T).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly)
             select m.IsStatic ?
                 AIFunctionFactory.Create(m, (object?)null, options) :
                 AIFunctionFactory.Create(m, args => args.Services is { } services ? ActivatorUtilities.CreateInstance<T>(services)! :  Activator.CreateInstance<T>()!, options))
            .ToList();

        return new FromTypeToolProvider(functions);
    }

    private sealed class FromTypeToolProvider(List<AIFunction> functions) : IToolProvider
    {
        public IEnumerable<AITool> GetTools() => functions;
    }
}

That would let you add IToolProviders into DI, and then either fetch them manually, or use the .UseToolProviders() middleware to automatically inject all tools from all IToolProviders from DI into your pipeline, e.g.

client = client.AsBuilder()
    .UseToolProviders()
    .UseFunctionInvocation()
    .UseOpenTelemetry()
    .Build(services);

This highlights a few things:

1. It doesn't need to be built into the framework to support this kind of customization. The middleware/pipeline/injection approach is powerful.
2. There are lots of variations in behaviors folks might want. For example, my implementation above will result in a new instance of the T plugin class being instantiated on each function invocation. That could be changed to instead be a single instance that's shared across all invocations if that's more desirable; that's more like what SK does today, but different from what ASP.NET and MCP both do (which is closer to what I wrote above).
3. If there were a really strong need for this, something along the lines of the above could be added to either Microsoft.Extensions.AI or Microsoft.Agents.AI.

cc: @rogerbarreto

[seiggy]

+1 on providing something along the lines above to either Microsoft.Agents.AI or it's own package even. I think going from SK where this was part of the framework to telling developers they need to build their own Tool Middleware is a loss of functionality. Even if it's designated as an opinionated provider, I'd prefer to see this back in the framework.

[ranpatterson]

+1 abstract away this unnecessary complexity

[sabbadino]

If I am not wrong, all examples here cover DI handling for constructors parameters, but SK handled also DI for method parameters.

Most of the time one does not need DI for parameters BUT i have met a scenario using MCP SDK where injecting the same type as parameter OR in the constructor did make a difference (since the object contained a property that was something like a session state for a callback . . maybe it was a bad design of the MCP SDK .. still )

Enrico