.Net: Allow inputs to be injected into OpenAPI plugins

[matthewbolanos]

With native functions, you can inject services that can provide additional information to plugins so the AI doesn't need to provide it.

For example, you may inject a UserContextService service that allows you to get the current user's ID so you can use it within the plugin without the LLM ever needing to know it and pass it in. This reduces token usage and simplifies the job of the AI.

Today, with OpenAPI plugins, this is not possible. This task is to resolve this gap.

[matthewbolanos]

Since OpenAPI specs are predominantly used for AI devs (Python) and app devs (C#) to work together. The "solution" to this should be serializable so it can be shared across languages. Perhaps using our template engines to inject inputs from other plugins

[SergeyMenshykh]

Added to the Ignite bucket but it needs more clarification before working on it.

[markwallace-microsoft]

This can be solved by transforming the plugin and allowing additional parameters to be injected. I will create a Blog Post showing how to do this for any type of KernelPlugin.

[joshbartley]

@markwallace-microsoft appreciate the original code. I modified it to remove magic strings so you can add in parameters that were removed without having to rely on them always being there.

var transformedPlugin = CreatePluginWithParameters(
    agentPlugin,
    (KernelParameterMetadata parameter) => parameter.ParameterType != typeof(IUser) ,
    (KernelFunctionMetadata function, KernelArguments arguments, IReadOnlyList<KernelParameterMetadata> originalParameter) => {
        var userParameter = originalParameter.Where(x => x.ParameterType == typeof(IUser)).FirstOrDefault();
        if (userParameter != null)
            arguments.Add(userParameter.Name, User);

    }
);

    public delegate bool IncludeKernelParameter(KernelParameterMetadata parameter);

    public delegate void UpdateKernelArguments(KernelFunctionMetadata function, KernelArguments arguments, IReadOnlyList<KernelParameterMetadata> originalParameter);

    /// <summary>
    /// Create a <see cref="KernelPlugin"/> instance from the provided instance where each function only includes
    /// permitted parameters. The <see cref="IncludeKernelParameter"/> delegate is called to determine whether or not
    /// parameter will be included. The <see cref="UpdateKernelArguments"/> delegate is called to update the arguments
    /// and allow additional values to be included.
    /// </summary>
    public static KernelPlugin CreatePluginWithParameters(KernelPlugin plugin, IncludeKernelParameter includeKernelParameter, UpdateKernelArguments updateKernelArguments)
    {
        List<KernelFunction>? functions = new();

        foreach (KernelFunction function in plugin)
        {
            functions.Add(CreateFunctionWithParameters(function, includeKernelParameter, updateKernelArguments));
        }

        return KernelPluginFactory.CreateFromFunctions(plugin.Name, plugin.Description, functions);
    }
     /// <summary>
/// Create a <see cref="KernelFunction"/> instance from the provided instance which only includes permitted parameters.
/// The function method will add additional argument values before calling the original function.
/// </summary>
private static KernelFunction CreateFunctionWithParameters(KernelFunction function, IncludeKernelParameter includeKernelParameter, UpdateKernelArguments updateKernelArguments)
{
    var originalParameters = function.Metadata.Parameters;

    var method = (Kernel kernel, KernelFunction currentFunction, KernelArguments arguments, CancellationToken cancellationToken) =>
    {
        updateKernelArguments(  currentFunction.Metadata, arguments, originalParameters);
        return function.InvokeAsync(kernel, arguments, cancellationToken);
    };

    var options = new KernelFunctionFromMethodOptions()
    {
        FunctionName = function.Name,
        Description = function.Description,
        Parameters = CreateParameterMetadataWithParameters(function.Metadata.Parameters, includeKernelParameter),
        ReturnParameter = function.Metadata.ReturnParameter,
    };

    return KernelFunctionFactory.CreateFromMethod(method, options);
}