chore: import upstream snapshot with attribution

dotnet/samples/GettingStartedWithProcesses/Step04/Steps/AgentGroupChatStep.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft. All rights reserved.
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Agents;
+using Microsoft.SemanticKernel.ChatCompletion;
+
+namespace Step04.Steps;
+
+/// <summary>
+/// This steps defines actions for the group chat in which to agents collaborate in
+/// response to input from the primary agent.
+/// </summary>
+public class AgentGroupChatStep : KernelProcessStep
+{
+    public const string ChatServiceKey = $"{nameof(AgentGroupChatStep)}:{nameof(ChatServiceKey)}";
+    public const string ReducerServiceKey = $"{nameof(AgentGroupChatStep)}:{nameof(ReducerServiceKey)}";
+
+    public static class ProcessStepFunctions
+    {
+        public const string InvokeAgentGroup = nameof(InvokeAgentGroup);
+    }
+
+    [KernelFunction(ProcessStepFunctions.InvokeAgentGroup)]
+    public async Task InvokeAgentGroupAsync(KernelProcessStepContext context, Kernel kernel, string input)
+    {
+        AgentGroupChat chat = kernel.GetRequiredService<AgentGroupChat>();
+
+        // Reset chat state from previous invocation
+        //await chat.ResetAsync();
+        chat.IsComplete = false;
+
+        ChatMessageContent message = new(AuthorRole.User, input);
+        chat.AddChatMessage(message);
+        await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.GroupMessage, Data = message });
+
+        await foreach (ChatMessageContent response in chat.InvokeAsync())
+        {
+            await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.GroupMessage, Data = response });
+        }
+
+        ChatMessageContent[] history = await chat.GetChatMessagesAsync().Reverse().ToArrayAsync();
+
+        // Summarize the group chat as a response to the primary agent
+        string summary = await kernel.SummarizeHistoryAsync(ReducerServiceKey, history);
+
+        await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.GroupCompleted, Data = summary });
+    }
+}

dotnet/samples/GettingStartedWithProcesses/Step04/Steps/ManagerAgentStep.cs

@@ -0,0 +1,120 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.ComponentModel;
+using System.Text.Json;
+using Events;
+using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Agents;
+using Microsoft.SemanticKernel.ChatCompletion;
+using Microsoft.SemanticKernel.Connectors.OpenAI;
+
+namespace Step04.Steps;
+
+/// <summary>
+/// This steps defines actions for the primary agent.  This agent is responsible forinteracting with
+/// the user as well as as delegating to a group of agents.
+/// </summary>
+public class ManagerAgentStep : KernelProcessStep
+{
+    public const string AgentServiceKey = $"{nameof(ManagerAgentStep)}:{nameof(AgentServiceKey)}";
+    public const string ReducerServiceKey = $"{nameof(ManagerAgentStep)}:{nameof(ReducerServiceKey)}";
+
+    public static class ProcessStepFunctions
+    {
+        public const string InvokeAgent = nameof(InvokeAgent);
+        public const string InvokeGroup = nameof(InvokeGroup);
+        public const string ReceiveResponse = nameof(ReceiveResponse);
+    }
+
+    [KernelFunction(ProcessStepFunctions.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();
+        ChatHistoryAgentThread agentThread = new(history);
+
+        // Obtain the agent response
+        ChatCompletionAgent agent = kernel.GetAgent<ChatCompletionAgent>(AgentServiceKey);
+        await foreach (ChatMessageContent message in agent.InvokeAsync(new ChatMessageContent(AuthorRole.User, userInput), agentThread))
+        {
+            // Both the input message and response message will automatically be added to the thread, which will update the internal chat history.
+
+            // 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 });
+    }
+
+    [KernelFunction(ProcessStepFunctions.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);
+
+        await context.EmitEventAsync(new() { Id = AgentOrchestrationEvents.GroupInput, Data = summary });
+    }
+
+    [KernelFunction(ProcessStepFunctions.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
+        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 });
+    }
+
+    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 OpenAIPromptExecutionSettings { ResponseFormat = typeof(IntentResult) });
+        IntentResult intent = JsonSerializer.Deserialize<IntentResult>(response.ToString())!;
+
+        logger.LogTrace("{StepName} Response Intent - {IsRequestingUserInput}: {Rationale}", nameof(ManagerAgentStep), intent.IsRequestingUserInput, intent.Rationale);
+
+        return intent;
+    }
+
+    [DisplayName("IntentResult")]
+    [Description("this is the result description")]
+    public sealed record IntentResult(
+        [property: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.")]
+        bool IsRequestingUserInput,
+        [property:Description("True if the user request is being worked on.")]
+        bool IsWorking,
+        [property:Description("Rationale for the value assigned to IsRequestingUserInput")]
+        string Rationale);
+}

dotnet/samples/GettingStartedWithProcesses/Step04/Steps/RenderMessageStep.cs

@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft. All rights reserved.
+using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.ChatCompletion;
+
+namespace Step04.Steps;
+
+/// <summary>
+/// Displays output to the user.  While in this case it is just writing to the console,
+/// in a real-world scenario this would be a more sophisticated rendering system.  Isolating this
+/// rendering logic from the internal logic of other process steps simplifies responsibility contract
+/// and simplifies testing and state management.
+/// </summary>
+public class RenderMessageStep : KernelProcessStep
+{
+    public static class ProcessStepFunctions
+    {
+        public const string RenderDone = nameof(RenderMessageStep.RenderDone);
+        public const string RenderError = nameof(RenderMessageStep.RenderError);
+        public const string RenderInnerMessage = nameof(RenderMessageStep.RenderInnerMessage);
+        public const string RenderMessage = nameof(RenderMessageStep.RenderMessage);
+        public const string RenderUserText = nameof(RenderMessageStep.RenderUserText);
+    }
+
+    private static readonly Stopwatch s_timer = Stopwatch.StartNew();
+
+    /// <summary>
+    /// Render an explicit message to indicate the process has completed in the expected state.
+    /// </summary>
+    /// <remarks>
+    /// If this message isn't rendered, the process is considered to have failed.
+    /// </remarks>
+    [KernelFunction]
+    public void RenderDone()
+    {
+        Render("DONE!");
+    }
+
+    /// <summary>
+    /// Render exception
+    /// </summary>
+    [KernelFunction]
+    public void RenderError(KernelProcessError error, ILogger logger)
+    {
+        string message = string.IsNullOrWhiteSpace(error.Message) ? "Unexpected failure" : error.Message;
+        Render($"ERROR: {message} [{error.GetType().Name}]{Environment.NewLine}{error.StackTrace}");
+        logger.LogError("Unexpected failure: {ErrorMessage} [{ErrorType}]", error.Message, error.Type);
+    }
+
+    /// <summary>
+    /// Render user input
+    /// </summary>
+    [KernelFunction]
+    public void RenderUserText(string message)
+    {
+        Render($"{AuthorRole.User.Label.ToUpperInvariant()}: {message}");
+    }
+
+    /// <summary>
+    /// Render an assistant message from the primary chat
+    /// </summary>
+    [KernelFunction]
+    public void RenderMessage(ChatMessageContent? message)
+    {
+        if (message is null)
+        {
+            // if the message is empty, we don't want to render it
+            return;
+        }
+
+        Render(message);
+    }
+
+    /// <summary>
+    /// Render an assistant message from the inner chat
+    /// </summary>
+    [KernelFunction]
+    public void RenderInnerMessage(ChatMessageContent message)
+    {
+        Render(message, indent: true);
+    }
+
+    public static void Render(ChatMessageContent message, bool indent = false)
+    {
+        string displayName = !string.IsNullOrWhiteSpace(message.AuthorName) ? $" - {message.AuthorName}" : string.Empty;
+        Render($"{(indent ? "\t" : string.Empty)}{message.Role.Label.ToUpperInvariant()}{displayName}: {message.Content}");
+    }
+
+    public static void Render(string message)
+    {
+        Console.WriteLine($"[{s_timer.Elapsed:mm\\:ss}] {message}");
+    }
+}