Getting input into a process step

[listentorick]

I'd like a "wait for user input step".

How can I pass data into a step independently of the process i.e. if the step exposed a method "AddUserMessage", how do I get hold of an instance of the step so I can send it a message?

Something like this:

` public class UserInputKernalProcessStep : KernelProcessStep
{
private TaskCompletionSource _userMessageTcs = new TaskCompletionSource();

/// <summary>
/// Adds a user message to be consumed by GetUserInputAsync
/// </summary>
/// <param name="message">The user input message</param>
public void AddUserMessage(string message)
{
    // Set the result of the TaskCompletionSource to the message
    _userMessageTcs.TrySetResult(message);
}

/// <summary>
/// Gets the user input asynchronously by waiting for a message to be provided.
/// Once a message is received, it emits the event.
/// </summary>
/// <param name="context">An instance of <see cref="KernelProcessStepContext"/> which can be
/// used to emit events from within a KernelFunction.</param>
/// <returns>A <see cref="ValueTask"/></returns>
[KernelFunction(Functions.GetUserInput)]
public override async ValueTask GetUserInputAsync(KernelProcessStepContext context)
{
    // Wait asynchronously for a user message to be provided
    var userMessage = await _userMessageTcs.Task;

    // Emit the event with the received message
    await context.EmitEventAsync(new() { Id = OpeningEvents.UserInputReceived, Data = userMessage });

    // Reset the TaskCompletionSource for future use (if needed)
    _userMessageTcs = new TaskCompletionSource<string>();
}

}`

The reason I want to do this, is I'm building a conversational UI over this!

[listentorick]

So.. it was embarrassingly obvious.. The kernal has a service provider! Leaving the answer here for others.

public class UserInputProvider
{
    private TaskCompletionSource<string> _messageTcs = new TaskCompletionSource<string>();
    private string _cachedMessage = null;  // Cache for the latest message




    /// <summary>
    /// Simulates the addition of a new user message.
    /// This could be triggered by an external input source.
    /// </summary>
    /// <param name="message">The user message to be provided.</param>
    public void AddUserMessage(string message)
    {
        _cachedMessage = message;  // Cache the message
        _messageTcs.TrySetResult(message);  // Complete the TaskCompletionSource for any waiting consumers
    }

    /// <summary>
    /// Waits asynchronously for a user message to be provided. If a message was already provided,
    /// it returns that immediately from the cache.
    /// </summary>
    /// <returns>The user input message.</returns>
    public async Task<string> GetUserMessageAsync()
    {
        // If a cached message exists, return it immediately
        if (_cachedMessage != null)
        {
            var message = _cachedMessage;
            _cachedMessage = null;  // Optionally clear the cache if you don't want it reused
            return message;
        }

        // Otherwise, wait for a new message
        var newMessage = await _messageTcs.Task;

        // Reset the TaskCompletionSource for future use
        _messageTcs = new TaskCompletionSource<string>();
        return newMessage;
    }
}

public class UserInputKernalProcessStep: KernelProcessStep
{


    /// <summary>
    /// Gets the user input.
    /// Could be overridden to customize the output events to be emitted
    /// </summary>
    /// <param name="context">An instance of <see cref="KernelProcessStepContext"/> which can be
    /// used to emit events from within a KernelFunction.</param>
    /// <returns>A <see cref="ValueTask"/></returns>
    [KernelFunction(Functions.GetUserInput)]
    public virtual async ValueTask GetUserInputAsync(KernelProcessStepContext context, Kernel kernel)
    {

        // Retrieve the UserInputProvider service from the Kernel
        UserInputProvider userInputProvider = kernel.GetRequiredService<UserInputProvider>();

        // Wait for a user message to be provided by the UserInputProvider
        var userMessage = await userInputProvider.GetUserMessageAsync();

        // Emit the event with the received user message
        await context.EmitEventAsync(new() { Id = OpeningEvents.UserInputReceived, Data = userMessage });

    }

}