agent-framework/dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/Condition.cs

// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
// </auto-generated>
// ------------------------------------------------------------------------------

#nullable enable
#pragma warning disable IDE0005 // Extra using directive is ok.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Agents.AI.Workflows.Declarative;
using Microsoft.Agents.AI.Workflows.Declarative.Kit;
using Microsoft.Extensions.AI;

namespace Test.WorkflowProviders;

/// <summary>
/// This class provides a factory method to create a <see cref="Workflow" /> instance.
/// </summary>
/// <remarks>
/// The workflow defined here was generated from a declarative workflow definition.
/// Declarative workflows utilize Power FX for defining conditions and expressions.
/// To learn more about Power FX, see:
/// https://learn.microsoft.com/power-platform/power-fx/formula-reference-copilot-studio
/// </remarks>
public static class WorkflowProvider
{
    /// <summary>
    /// The root executor for a declarative workflow.
    /// </summary>
    internal sealed class MyWorkflowRootExecutor<TInput>(
        DeclarativeWorkflowOptions options,
        Func<TInput, ChatMessage> inputTransform) :
        RootExecutor<TInput>("my_workflow_Root", options, inputTransform)
        where TInput : notnull
    {
        protected override async ValueTask ExecuteAsync(TInput message, IWorkflowContext context, CancellationToken cancellationToken)
        {
            // Initialize variables
            await context.QueueStateUpdateAsync("TestValue", UnassignedValue.Instance, "Local").ConfigureAwait(false);
        }
    }

    /// <summary>
    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.TestValue" variable.
    /// </summary>
    internal sealed class SetvariableTestExecutor(FormulaSession session) : ActionExecutor(id: "setVariable_test", session)
    {
        // <inheritdoc />
        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
        {
            object? evaluatedValue = await context.EvaluateValueAsync<object>("Value(System.LastMessageText)").ConfigureAwait(false);
            await context.QueueStateUpdateAsync(key: "TestValue", value: evaluatedValue, scopeName: "Local").ConfigureAwait(false);

            return default;
        }
    }

    /// <summary>
    /// Conditional branching similar to an if / elseif / elseif / else chain.
    /// </summary>
    internal sealed class ConditiongroupTestExecutor(FormulaSession session) : ActionExecutor(id: "conditionGroup_test", session)
    {
        // <inheritdoc />
        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
        {
            bool condition0 = await context.EvaluateValueAsync<bool>("Mod(Local.TestValue, 2) = 1").ConfigureAwait(false);
            if (condition0)
            {
                return "conditionItem_odd";
            }

            bool condition1 = await context.EvaluateValueAsync<bool>("Mod(Local.TestValue, 2) = 0").ConfigureAwait(false);
            if (condition1)
            {
                return "conditionItem_even";
            }

            return "conditionGroup_testElseActions";
        }
    }

    /// <summary>
    /// Formats a message template and sends an activity event.
    /// </summary>
    internal sealed class SendactivityOddExecutor(FormulaSession session) : ActionExecutor(id: "sendActivity_odd", session)
    {
        // <inheritdoc />
        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
        {
            string activityText =
                await context.FormatTemplateAsync(
                    """
                    ODD
                    """
                );
            AgentResponse response = new([new ChatMessage(ChatRole.Assistant, activityText)]);
            await context.AddEventAsync(new AgentResponseEvent(this.Id, response)).ConfigureAwait(false);

            return default;
        }
    }

    /// <summary>
    /// Formats a message template and sends an activity event.
    /// </summary>
    internal sealed class SendactivityEvenExecutor(FormulaSession session) : ActionExecutor(id: "sendActivity_even", session)
    {
        // <inheritdoc />
        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
        {
            string activityText =
                await context.FormatTemplateAsync(
                    """
                    EVEN
                    """
                );
            AgentResponse response = new([new ChatMessage(ChatRole.Assistant, activityText)]);
            await context.AddEventAsync(new AgentResponseEvent(this.Id, response)).ConfigureAwait(false);

            return default;
        }
    }

    /// <summary>
    /// Formats a message template and sends an activity event.
    /// </summary>
    internal sealed class ActivityFinalExecutor(FormulaSession session) : ActionExecutor(id: "activity_final", session)
    {
        // <inheritdoc />
        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
        {
            string activityText =
                await context.FormatTemplateAsync(
                    """
                    All done!
                    """
                );
            AgentResponse response = new([new ChatMessage(ChatRole.Assistant, activityText)]);
            await context.AddEventAsync(new AgentResponseEvent(this.Id, response)).ConfigureAwait(false);

            return default;
        }
    }

    public static Workflow CreateWorkflow<TInput>(
        DeclarativeWorkflowOptions options,
        Func<TInput, ChatMessage>? inputTransform = null)
        where TInput : notnull
    {
        // Create root executor to initialize the workflow.
        inputTransform ??= (message) => DeclarativeWorkflowBuilder.DefaultTransform(message);
        MyWorkflowRootExecutor<TInput> myWorkflowRoot = new(options, inputTransform);
        DelegateExecutor myWorkflow = new(id: "my_workflow", myWorkflowRoot.Session);
        SetvariableTestExecutor setVariableTest = new(myWorkflowRoot.Session);
        ConditiongroupTestExecutor conditionGroupTest = new(myWorkflowRoot.Session);
        DelegateExecutor conditionItemOdd = new(id: "conditionItem_odd", myWorkflowRoot.Session);
        DelegateExecutor conditionItemEven = new(id: "conditionItem_even", myWorkflowRoot.Session);
        DelegateExecutor conditionItemOddactions = new(id: "conditionItem_oddActions", myWorkflowRoot.Session);
        SendactivityOddExecutor sendActivityOdd = new(myWorkflowRoot.Session);
        DelegateExecutor conditionItemEvenactions = new(id: "conditionItem_evenActions", myWorkflowRoot.Session);
        SendactivityEvenExecutor sendActivityEven = new(myWorkflowRoot.Session);
        DelegateExecutor conditionGroupTestPost = new(id: "conditionGroup_test_Post", myWorkflowRoot.Session);
        ActivityFinalExecutor activityFinal = new(myWorkflowRoot.Session);
        DelegateExecutor conditionItemOddPost = new(id: "conditionItem_odd_Post", myWorkflowRoot.Session);
        DelegateExecutor conditionItemEvenPost = new(id: "conditionItem_even_Post", myWorkflowRoot.Session);
        DelegateExecutor conditionItemOddactionsPost = new(id: "conditionItem_oddActions_Post", myWorkflowRoot.Session);
        DelegateExecutor conditionItemEvenactionsPost = new(id: "conditionItem_evenActions_Post", myWorkflowRoot.Session);

        // Define the workflow builder
        WorkflowBuilder builder = new(myWorkflowRoot);

        // Connect executors
        builder.AddEdge(myWorkflowRoot, myWorkflow);
        builder.AddEdge(myWorkflow, setVariableTest);
        builder.AddEdge(setVariableTest, conditionGroupTest);
        builder.AddEdge(conditionGroupTest, conditionItemOdd, (object? result) => ActionExecutor.IsMatch("conditionItem_odd", result));
        builder.AddEdge(conditionGroupTest, conditionItemEven, (object? result) => ActionExecutor.IsMatch("conditionItem_even", result));
        builder.AddEdge(conditionItemOdd, conditionItemOddactions);
        builder.AddEdge(conditionItemOddactions, sendActivityOdd);
        builder.AddEdge(conditionItemEven, conditionItemEvenactions);
        builder.AddEdge(conditionItemEvenactions, sendActivityEven);
        builder.AddEdge(conditionGroupTestPost, activityFinal);
        builder.AddEdge(conditionItemOddPost, conditionGroupTestPost);
        builder.AddEdge(conditionItemEvenPost, conditionGroupTestPost);
        builder.AddEdge(sendActivityOdd, conditionItemOddactionsPost);
        builder.AddEdge(conditionItemOddactionsPost, conditionItemOddPost);
        builder.AddEdge(sendActivityEven, conditionItemEvenactionsPost);
        builder.AddEdge(conditionItemEvenactionsPost, conditionItemEvenPost);

        // Build the workflow
        return builder.Build(validateOrphans: false);
    }
}