Need help to Create Dynamic AgentGroupChat Using Process Framework

[lovedeepatsgit]

I have tried to modify https://github.com/microsoft/semantic-kernel/tree/main/dotnet/samples/GettingStartedWithProcesses/Step04, To generate Dynamic AgentGroupChat, the error i am getting is as below:

---

Program.cs is as below:

using Events;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.Agents.Chat;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;
using Microsoft.SemanticKernel.Connectors.OpenAI;
using ProdGenAi.Core.Interfaces;
using ProdGenAi.Core.Plugins;
using ProdGenAi.Core.Services;
using ProdGenAi.Core.Strategies;
using ProdGenAi.Core.StrategyFunctions;
using SharedSteps;
using Step04.Plugins;
using Step04.Steps;

namespace Step04;

public class Step04_AgentOrchestration
{
static async Task Main()
{
Step04_AgentOrchestration orchestration = new();
await orchestration.DelegatedGroupChatAsync();
}

public async Task DelegatedGroupChatAsync()
{
    // Define process
    KernelProcess process = SetupAgentProcess<BasicAgentChatUserInput>(nameof(DelegatedGroupChatAsync));

    // Execute process
    await RunProcessAsync(process);
}

private sealed class BasicAgentChatUserInput : ScriptedUserInputStep
{
    public override async ValueTask GetUserInputAsync(KernelProcessStepContext context)
    {
        var userMessage = this.GetNextUserMessage();

        if (string.Equals(userMessage, "exit", StringComparison.OrdinalIgnoreCase))
        {
            await context.EmitEventAsync(new() { Id = CommonEvents.Exit, Data = userMessage });
            return;
        }

        await context.EmitEventAsync(new() { Id = CommonEvents.UserInputReceived, Data = userMessage });
    }
}

private async Task RunProcessAsync(KernelProcess process)
{
    // Initialize services
    ChatHistory history = [];
    Kernel kernel = SetupKernel(history);

    // Execute process
    using LocalKernelProcessContext localProcess =
        await process.StartAsync(
            kernel,
            new KernelProcessEvent()
            {
                Id = AgentOrchestrationEvents.StartProcess
            });

    // Demonstrate history is maintained independent of process state
    //this.WriteHorizontalRule();
    foreach (ChatMessageContent message in history)
    {
        RenderMessageStep.Render(message);
    }
}

private KernelProcess SetupAgentProcess<TUserInputStep>(string processName) where TUserInputStep : ScriptedUserInputStep
{
    ProcessBuilder process = new(processName);

    var introStep = process.AddStepFromType<IntroStep>();
    var userInputStep = process.AddStepFromType<TUserInputStep>();
    var renderMessageStep = process.AddStepFromType<RenderMessageStep>();
    var managerAgentStep = process.AddStepFromType<ManagerAgentStep>();
    var agentGroupStep = process.AddStepFromType<AgentGroupChatStep>();

    AttachErrorStep(
        userInputStep,
        ScriptedUserInputStep.Functions.GetUserInput);

    AttachErrorStep(
        managerAgentStep,
        ManagerAgentStep.Functions.InvokeAgent,
        ManagerAgentStep.Functions.InvokeGroup,
        ManagerAgentStep.Functions.ReceiveResponse);

    AttachErrorStep(
        agentGroupStep,
        AgentGroupChatStep.Functions.InvokeAgentGroup);

    // Entry point
    process.OnInputEvent(AgentOrchestrationEvents.StartProcess)
        .SendEventTo(new ProcessFunctionTargetBuilder(introStep));

    //To Provide Starting Information
    introStep.OnFunctionResult()
        .SendEventTo(new ProcessFunctionTargetBuilder(userInputStep));

    // Pass user input to primary agent
    userInputStep
        .OnEvent(CommonEvents.UserInputReceived)
        .SendEventTo(new ProcessFunctionTargetBuilder(managerAgentStep, ManagerAgentStep.Functions.InvokeAgent))
        .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.Functions.RenderUserText, parameterName: "message"));

    // Render response from primary agent
    managerAgentStep
        .OnEvent(AgentOrchestrationEvents.AgentResponse)
        .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.Functions.RenderMessage, parameterName: "message"));

    // Request is completed But can Assist further if Needed.
    managerAgentStep
        .OnEvent(CommonEvents.UserInputComplete)
        .SendEventTo(new ProcessFunctionTargetBuilder(userInputStep));

    // Request more user input
    managerAgentStep
        .OnEvent(AgentOrchestrationEvents.AgentResponded)
        .SendEventTo(new ProcessFunctionTargetBuilder(userInputStep));
    
    //Create Group of Agents
    managerAgentStep
        .OnEvent(AgentOrchestrationEvents.AgentWorking)
        .SendEventTo(new ProcessFunctionTargetBuilder(managerAgentStep, ManagerAgentStep.Functions.CreateGroup, parameterName: "requiredAgents"));

    //Delegate to inner agents
    managerAgentStep
        .OnEvent(AgentOrchestrationEvents.AgentGroupCreated)
        .SendEventTo(new ProcessFunctionTargetBuilder(managerAgentStep, ManagerAgentStep.Functions.InvokeGroup));

    // Provide input to inner agents
    managerAgentStep
        .OnEvent(AgentOrchestrationEvents.GroupInput)
        .SendEventTo(new ProcessFunctionTargetBuilder(agentGroupStep, parameterName: "input"));

    // Render response from inner chat (for visibility)
    agentGroupStep
        .OnEvent(AgentOrchestrationEvents.GroupMessage)
        .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.Functions.RenderInnerMessage, parameterName: "message"));

    // Provide inner response to primary agent
    agentGroupStep
        .OnEvent(AgentOrchestrationEvents.GroupCompleted)
        .SendEventTo(new ProcessFunctionTargetBuilder(userInputStep));

    KernelProcess kernelProcess = process.Build();

    return kernelProcess;

    void AttachErrorStep(ProcessStepBuilder step, params string[] functionNames)
    {
        foreach (string functionName in functionNames)
        {
            step
                .OnFunctionError(functionName)
                .SendEventTo(new ProcessFunctionTargetBuilder(renderMessageStep, RenderMessageStep.Functions.RenderError, "error"))
                .StopProcess();
        }
    }
}

private Kernel SetupKernel(ChatHistory history)
{
    // Load configuration once
    var configuration = new ConfigurationBuilder()
                        .SetBasePath(Directory.GetCurrentDirectory())
                        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                        .Build();

    // Initialize kernel builder with centralized configuration
    IKernelBuilder builder = Kernel.CreateBuilder();

    // Add Azure OpenAI Chat Completion
    builder.AddAzureOpenAIChatCompletion(
        configuration["LlmModels:GPT-4o-2"]!,
        configuration["LlmModels:AiFoundryEndpoint"]!,
        configuration["LlmModels:AiFoundryApiKey"]!);

    // Set up agents and services using the centralized configuration
    SetupAgents(builder, configuration);

    // Inject history provider
    builder.Services.AddSingleton<IChatHistoryProvider>(new ChatHistoryProvider(history));

    return builder.Build();
}

private const string ManagerInstructions =
    """
    Your primary role is to manage the conversation and delegate to the group chat.
    If User ask any question rather than Lesson Plan Generation, You answer the question.
    Before delegating, you should ask the information from the user about the Standard, Grade, and Kagan structure required or not.
    If, the user provided the information, then you should delegate the information to the group chat, other you have to ask the information again.
    When You feel that you have enough information, you need delegate the further conversation to the group chat.
    When you delegate the conversation to the group chat, you should inform that user that you are working and assigned the task to the group chat.
    You need to tell the user what agents you will choose in the group Chat from the below list:
    1. curriculumAgent (Description: This agent will generate the lesson plan based on the particular Standard)
    2. assessmentAgent (Description: This agent will generate the assessment plan based on lesson  plan needed with curriculumAgent)
    3. kaganAgent (Description: This agent will provide the Kagan structure if needed)
    Note: While choosing agents always choose assessmentAgent when curriculumAgent is selected.
    """;

private const string ManagerSummaryInstructions =
    """
    Summarize the most recent user request in first person command form.
    """;

private const string SuggestionSummaryInstructions =
    """
    Address the user directly with a summary of the response.
    """;

private static void SetupAgents(IKernelBuilder builder, IConfiguration configuration)
{
    // Create primary agent
    Kernel tempKernel = builder.Build(); // Temporary kernel for agent creation
    ChatCompletionAgent managerAgent = CreateAgent("Manager", ManagerInstructions, tempKernel);
    builder.Services.AddKeyedSingleton(ManagerAgentStep.AgentServiceKey, managerAgent);

    // Set up reducers
    builder.Services.AddKeyedSingleton(
        ManagerAgentStep.ReducerServiceKey,
        SetupReducer(tempKernel, ManagerSummaryInstructions));
    builder.Services.AddKeyedSingleton(
        AgentGroupChatStep.ReducerServiceKey,
        SetupReducer(tempKernel, SuggestionSummaryInstructions));
}

private static ChatHistorySummarizationReducer SetupReducer(Kernel kernel, string instructions) =>
     new(kernel.GetRequiredService<IChatCompletionService>(), 1)
     {
         SummarizationInstructions = instructions
     };

private static ChatCompletionAgent CreateAgent(string name, string instructions, Kernel kernel) =>
    new()
    {
        Name = name,
        Instructions = instructions,
        Kernel = kernel.Clone(),
        Arguments =
            new KernelArguments(
                new AzureOpenAIPromptExecutionSettings
                {
                    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(),
                    Temperature = 0,
                }),
    };

}

ManagerAgentStep.cs is as below:

// Copyright (c) Microsoft. All rights reserved.
using System.ComponentModel;
using System.Text.Json;
using Events;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.Agents.Chat;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;
using Microsoft.SemanticKernel.Connectors.OpenAI;
using ProdGenAi.Core.Services;
using ProdGenAi.Core.Strategies;
using ProdGenAi.Core.StrategyFunctions;
using ChatResponseFormat = OpenAI.Chat.ChatResponseFormat;

namespace Step04.Steps;

///

/// This steps defines actions for the primary agent. This agent is responsible for interacting with
/// the user as well as as delegating to a group of agents.
///

public class ManagerAgentStep : KernelProcessStep
{
public const string AgentServiceKey = $"{nameof(ManagerAgentStep)}:{nameof(AgentServiceKey)}";
public const string ReducerServiceKey = $"{nameof(ManagerAgentStep)}:{nameof(ReducerServiceKey)}";

public static class Functions
{
    public const string CreateGroup = nameof(CreateGroup);
    public const string InvokeAgent = nameof(InvokeAgent);
    public const string InvokeGroup = nameof(InvokeGroup);
    public const string ReceiveResponse = nameof(ReceiveResponse);
}

[KernelFunction(Functions.InvokeAgent)]
public async Task InvokeAgentAsync(KernelProcessStepContext context, Kernel kernel, string userInput, ILogger logger)
{
    // Get the chat history
    IChatHistoryProvider historyProvider = kernel.GetHistory();
    ChatHistory history = await historyProvider.GetHistoryAsync();

    // Add the user input to the chat history
    history.Add(new ChatMessageContent(AuthorRole.User, userInput));

    // Obtain the agent response
    ChatCompletionAgent agent = kernel.GetAgent<ChatCompletionAgent>(AgentServiceKey);
    await foreach (ChatMessageContent message in agent.InvokeAsync(history))
    {
        // Capture each response
        history.Add(message);

        System.Console.ForegroundColor = ConsoleColor.Yellow;
        System.Console.WriteLine($"ASSISTANT: {message.Content}");
        System.Console.ResetColor();

        // Emit event for each agent response
        await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.AgentResponse, Data = message });
    }

    // Commit any changes to the chat history
    await historyProvider.CommitAsync();

    // Evaluate current intent
    IntentResult intent = await IsRequestingUserInputAsync(kernel, history, logger);

    string intentEventId =
        intent.IsRequestingUserInput ?
            AgentOrchestrationEvents.AgentResponded :
            intent.IsWorking ?
                AgentOrchestrationEvents.AgentWorking :
                CommonEvents.UserInputComplete;

    await context.EmitEventAsync(new() { Id = intentEventId, Data = new List<string> { string.Join(", ", intent.Agents) } });
}

[KernelFunction(Functions.CreateGroup)]
public async Task CreateGroupAsync(List<ChatCompletionAgent> requiredAgents, IKernelBuilder builder, Kernel kernel, KernelProcessStepContext context, IServiceCollection services)
{
    var configuration = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
        .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json", optional: true)
        .Build();

    var agentbuilder = new AgentCreationService(kernel, configuration);

    ChatCompletionAgent curriculumAgent = agentbuilder.CreateAgent("CurriculumGeneratorTemplate.yml");
    ChatCompletionAgent assessmentAgent = agentbuilder.CreateAgent("AssessmentGeneratorTemplate.yml");
    ChatCompletionAgent kaganAgent = agentbuilder.CreateAgent("KaganAgentTemplate.yml");

    // Create strategies and AgentGroupChat
    KernelFunction selectionFunction = SelectionFunction.CreateSelectionFunction(requiredAgents);
    AgentSelectionStrategy selectionStrategy = new(selectionFunction, kernel, requiredAgents[0]);

    KernelFunction terminationFunction = TerminationFunction.CreateTerminationFunction();
    AgentTerminationStrategy terminationStrategy = new(terminationFunction, kernel, requiredAgents);

    AgentGroupChat agentGroupChat = new(requiredAgents.ToArray())
    {
        ExecutionSettings = new AgentGroupChatSettings
        {
            SelectionStrategy = selectionStrategy,
            TerminationStrategy = terminationStrategy
        }
    };

    // Register AgentGroupChat with the ServiceCollection
    services.AddSingleton(agentGroupChat);

    System.Console.ForegroundColor = ConsoleColor.Magenta;
    System.Console.WriteLine("MANAGER HAS CREATED THE GROUP CHAT");
    System.Console.ResetColor();

    await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.AgentGroupCreated, Data = agentGroupChat });
}

[KernelFunction(Functions.InvokeGroup)]
public async Task InvokeGroupAsync(KernelProcessStepContext context, Kernel kernel)
{
    // Get the chat history
    IChatHistoryProvider historyProvider = kernel.GetHistory();
    ChatHistory history = await historyProvider.GetHistoryAsync();

    // Summarize the conversation with the user to use as input to the agent group
    string summary = await kernel.SummarizeHistoryAsync(ReducerServiceKey, history);

    System.Console.WriteLine($"MANAGER HAS SENT THE RESPONSE TO GROUP CHAT WITH SUMMARY: {summary}");

    await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.GroupInput, Data = summary });
}

[KernelFunction(Functions.ReceiveResponse)]
public async Task ReceiveResponseAsync(KernelProcessStepContext context, Kernel kernel, string response)
{
    // Get the chat history
    IChatHistoryProvider historyProvider = kernel.GetHistory();
    ChatHistory history = await historyProvider.GetHistoryAsync();

    // Proxy the inner response
    System.Console.WriteLine("MANAGER HAS RECIEVED THE CONVERSION OF___GROUPCHAT");

    ChatCompletionAgent agent = kernel.GetAgent<ChatCompletionAgent>(AgentServiceKey);
    ChatMessageContent message = new(AuthorRole.Assistant, response) { AuthorName = agent.Name };
    history.Add(message);

    await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.AgentResponse, Data = message });

    await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.AgentResponded });
}

// Define the method to analyze user input intent
private static async Task<IntentResult> IsRequestingUserInputAsync(Kernel kernel, ChatHistory history, ILogger logger)
{
    ChatHistory localHistory =
    [
        new ChatMessageContent(AuthorRole.System, "Analyze the conversation and determine if user input is being solicited."),
    .. history.TakeLast(1)
    ];

    IChatCompletionService service = kernel.GetRequiredService<IChatCompletionService>();

    ChatMessageContent response = await service.GetChatMessageContentAsync(localHistory, new AzureOpenAIPromptExecutionSettings { ResponseFormat = s_intentResponseFormat });
    IntentResult intent = JsonSerializer.Deserialize<IntentResult>(response.ToString())!;

    logger.LogTrace("{StepName} Response Intent - {IsRequestingUserInput}: {Rationale}", nameof(ManagerAgentStep), intent.IsRequestingUserInput, intent.Rationale);
    System.Console.ForegroundColor = ConsoleColor.Red;
    System.Console.WriteLine($"intent: IsRequestingUserInput={intent.IsRequestingUserInput}, IsWorking={intent.IsWorking}, Rationale={intent.Rationale}, Agents=[{string.Join(", ", intent.Agents)}]");
    System.Console.ResetColor();
    return intent;

    
}

// Define the JSON schema manually instead of using JsonSchemaGenerator.FromType<IntentResult>()
private static readonly ChatResponseFormat s_intentResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
    jsonSchemaFormatName: "intent_result",
    jsonSchema: BinaryData.FromString("""
                                        {
                                            "type": "object",
                                            "properties": {
                                                "IsRequestingUserInput": { "type": "boolean", "description": "True if user input is requested or solicited. Addressing the user with no specific request is False. Asking a question to the user is True." },
                                                "IsWorking": { "type": "boolean", "description": "True if the user request is being worked on." },
                                                "Rationale": { "type": "string", "description": "Rationale for the value assigned to IsRequestingUserInput." },
                                                "Agents": { "type": "array", "items": { "type": "string" }, "description": "List of agents that are needed in the GroupChat, Keep Exact names as used in ChatHistor()" }
                                            },
                                            "required": ["IsRequestingUserInput", "IsWorking", "Rationale","Agents"],
                                            "additionalProperties": false
                                        }
                                        """),
    jsonSchemaIsStrict: true
);

// Define the IntentResult model for deserialization
public sealed record IntentResult(
    bool IsRequestingUserInput,
    bool IsWorking,
    string Rationale,
    List<string> Agents
);

}