EmitExternalEventAsync Method does not have data parameter ( Process Framework)

[lovedeepatsgit]

The Above is Definition EmitExternalEventAsync Method I am currently using Microsoft.Semantic Kernel 1.37.0, and While referring to the documentation of the Process Framework (https://learn.microsoft.com/en-us/semantic-kernel/frameworks/process/examples/example-human-in-loop?pivots=programming-language-csharp), there is one step that mentions that "await context.EmitExternalEventAsync("HumanApprovalRequired", data: documentation);", But as shown in the Screen Captures There is No option to use data attribute, Below is the screen capture of the Documentation:

---

Below is the Code which I am using:

using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel;
using Microsoft.Extensions.Configuration;
using static GenerateDocumentationStep;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;
using System.ComponentModel;
using System.Text.Json;

///Below i have defined the steps that are needed in the process, Next I will define the process flow, how these steps will be executed.
ProcessBuilder processBuilder = new("DocumentationGeneration");

//Addig the steps to the process
var infogatheringstep = processBuilder.AddStepFromType();
var generatedocsstep = processBuilder.AddStepFromType();
var docsProofreadStep = processBuilder.AddStepFromType();
var publishdocstep = processBuilder.AddStepFromType();

//Orchestrating the steps
processBuilder
.OnInputEvent("Start")
.SendEventTo(new(infogatheringstep));

processBuilder
.OnInputEvent("HumanApprovalResponse")
.SendEventTo(new(publishdocstep, parameterName: "isApproved"));

infogatheringstep
.OnFunctionResult()
.SendEventTo(new(generatedocsstep, functionName: "GenerateDocumentationAsync"));

generatedocsstep
.OnEvent("DocumentationGenerated")
.SendEventTo(new(docsProofreadStep));

docsProofreadStep
.OnEvent("DocumentationRejected")
.SendEventTo(new(generatedocsstep, functionName: "ApplySuggestionsAsync"));

docsProofreadStep
.OnEvent("DocumentationApproved")
.SendEventTo(new(publishdocstep, parameterName: "docs"));

var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.Build();

// Register Kernel and Agents
string? AZURE_OPEN_AI_ENDPOINT = configuration["LlmModels:AiFoundryEndpoint"];
string? AZURE_OPEN_AI_KEY = configuration["LlmModels:AiFoundryApiKey"];
string? DEPLOYMENT_MODEL = configuration["LlmModels:GPT-4o-2"];

Kernel kernel = Kernel.CreateBuilder()
.AddAzureOpenAIChatCompletion(DEPLOYMENT_MODEL!, AZURE_OPEN_AI_ENDPOINT!, AZURE_OPEN_AI_KEY!)
.Build();

var process = processBuilder.Build();
await process.StartAsync(kernel, new KernelProcessEvent { Id = "Start", Data = "Tata Tea" });
await process.StartAsync(kernel, new KernelProcessEvent { Id = "HumanApprovalResponse", Data = true });

//Definig a process to gather information about a product
public class GatherProductInfoStep : KernelProcessStep
{
[KernelFunction]
public string GatherProductInfo(string productName)
{
Console.WriteLine($"{nameof(GatherProductInfoStep)}:\n\t Gathering Trial Info About: {productName}");
return
$"""
The Information about the product: {productName}
""";
}
}

public class GenerateDocumentationStep : KernelProcessStep
{
private GenerateDocumentationStepState _state = new();

private string prompt = "You are an helpful Ai Assistant and You Have to write 2 Sentences about the product.";

public static class Functions
{
    public const string GenerateDocumentationAsync = nameof(GenerateDocumentationAsync);
    public const string ApplySuggestionsAsync = nameof(ApplySuggestionsAsync);
}

override public ValueTask ActivateAsync(KernelProcessStepState<GenerateDocumentationStepState> state)
{
    this._state = state.State!;
    this._state.ChatHistory ??= new ChatHistory(prompt);

    return base.ActivateAsync(state);
}

[KernelFunction(Functions.GenerateDocumentationAsync)]
public async Task<string> GenerateDocumentationAsync(Kernel kernel, KernelProcessStepContext context, string productinfo)
{
    Console.WriteLine($"{nameof(GenerateDocumentationStep)}:\n\tGenerating documentation for provided productInfo...");
    this._state.ChatHistory!.AddUserMessage($"The product information is: {productinfo}");

    IChatCompletionService chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();
    var aigeneratedresponse = await chatCompletionService.GetChatMessageContentAsync(this._state.ChatHistory!);
    //Console.WriteLine(aigeneratedresponse);

    await context.EmitEventAsync("DocumentationGenerated", aigeneratedresponse.Content!.ToString());
    //Console.WriteLine(aigeneratedresponse.Content!.ToString());

    return aigeneratedresponse.Content!.ToString();
}

[KernelFunction(Functions.ApplySuggestionsAsync)]
public async Task<string> ApplySuggestionsAsync(Kernel kernel, KernelProcessStepContext context, string suggestions)
{
    //Console Write Line is needed here
    this._state.ChatHistory!.AddUserMessage($"Rewrite the Documentation with the following suggestions:\n\n {suggestions}");

    IChatCompletionService chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();
    var aigeneratedresponse = await chatCompletionService.GetChatMessageContentAsync(this._state.ChatHistory!);

    await context.EmitEventAsync("DocumentationGenerated", aigeneratedresponse.Content!.ToString());

    return aigeneratedresponse.Content!.ToString();
}
public class GenerateDocumentationStepState
{
    public ChatHistory? ChatHistory { get; set; }
}

}

public class ProofReadingStep : KernelProcessStep
{
[KernelFunction]
public async Task ProofReadDocumentationAsync(Kernel kernel, KernelProcessStepContext context, string documentation)
{
Console.WriteLine($"{nameof(ProofReadingStep)}:\n\tProofreading the documentation...");

    string proofreadprompt =
        """"
        You task is to proof read the provided documentation and make sure it is free from any errors.
        You need to check for any gramatical error or any other error in the documentation.
        Documentation should have exactly 5 sentences. about the product.
        If the documentation does not pass any point, you must write detailed feedback of the changes that are needed to improve the documentation.
        """";
    ChatHistory chatHistory = new ChatHistory(proofreadprompt);
    chatHistory.AddUserMessage(documentation);

    AzureOpenAIPromptExecutionSettings settings = new AzureOpenAIPromptExecutionSettings();
    settings.ResponseFormat = typeof(ProofReadingResponse);

    IChatCompletionService chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();
    var proofReaderResponse = await chatCompletionService.GetChatMessageContentAsync(chatHistory, settings);
    var formatResponse = JsonSerializer.Deserialize<ProofReadingResponse>(proofReaderResponse.Content!.ToString());

    Console.WriteLine($"\n\tGrade: {(formatResponse!.MeetsExpectations ? "Pass" : "Fail")}\n\tExplanation: {formatResponse.Explanation}\n\tSuggestions: {String.Join("\n\t",formatResponse.Suggestions)}");

    if (formatResponse.MeetsExpectations)
    {
        await context.EmitEventAsync("DocumentationApproved", data: documentation);
        await context.EmitExternalEventAsync("HumanApprovalRequired", documentation);
    }
    else
    {
        await context.EmitEventAsync("DocumentationRejected", data: new {Explanation = formatResponse.Explanation, Suggestions = formatResponse.Suggestions});
    }
}

public class  ProofReadingResponse
{
    [Description("Specifies if the proposed documentation meets the expected standards for publishing.")]
    public bool MeetsExpectations { get; set; }

    [Description("An explanation of why the documentation does or does not meet expectations.")]
    public string Explanation { get; set; } = "";

    [Description("A lis of suggestions, may be empty if there no suggestions for improvement.")]
    public List<string> Suggestions { get; set; } = new();
}

}

public class PublishDocumentationStep : KernelProcessStep
{
[KernelFunction]
public void PublishDocumentation(string docs, bool isApproved)
{
if (isApproved)
{
Console.WriteLine($"{nameof(PublishDocumentationStep)}:\n\tPublishing product documentation:\n\n{docs}");
}
}
}

---

The output I am receiving is Below:

Here, the Program exits without my consent, How I can resolve this Issue.

[moonbox3]

Tagging @alliscode for visibility.

[mickbut-ler]

@lovedeepatsgit any updates on this?

[lovedeepatsgit]

Not yet @mickbut-ler

[lovedeepatsgit]

I have used simple EmitEventAsync method at the place of EmitExternalEventAsync, which has Data Parameter.

[moonbox3]

@esttenorio could you have a look at this, please?

[esttenorio]

As of now, the documentation is out-of-date. We'll be updating the documentation in the upcoming weeks + adding Demo/samples.
With the current changes in the repo, there is a new component called ProxyStep.
This new abstraction component helps keep the steps with their desired functionality and do the "external hook up" in the Process Builder configuration layer only.
For now, it is only referenced in some Unit Tests in the repo - LocalProxyTests.cs

Hopefully this gets you unblocked for now.

[lovedeepatsgit]

Thanks a Lot @esttenorio