chore: import upstream snapshot with attribution

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/AddConversationMessage.cs

@@ -0,0 +1,119 @@
+// ------------------------------------------------------------------------------
+// <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 WorkflowTestRootExecutor<TInput>(
+        DeclarativeWorkflowOptions options,
+        Func<TInput, ChatMessage> inputTransform) :
+        RootExecutor<TInput>("workflow_test_Root", options, inputTransform)
+        where TInput : notnull
+    {
+        protected override async ValueTask ExecuteAsync(TInput message, IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            // Initialize variables
+            await context.QueueStateUpdateAsync("MyMessage1", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("TestInput", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Adds a new message to the specified agent conversation
+    /// </summary>
+    internal sealed class AddMessageExecutor(FormulaSession session, ResponseAgentProvider agentProvider) : ActionExecutor(id: "add_message", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string? conversationId = await context.ReadStateAsync<string>(key: "ConversationId", scopeName: "System").ConfigureAwait(false);
+            if (string.IsNullOrWhiteSpace(conversationId))
+            {
+                throw new DeclarativeActionException($"Conversation identifier must be defined: {this.Id}");
+            }
+            ChatMessage newMessage = new(ChatRole.User, await this.GetContentAsync(context).ConfigureAwait(false)) { AdditionalProperties = this.GetMetadata() };
+            newMessage = await agentProvider.CreateMessageAsync(conversationId, newMessage, cancellationToken).ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "MyMessage1", value: newMessage, scopeName: "Local").ConfigureAwait(false);
+    
+            return default;
+        }
+    
+        private async ValueTask<IList<AIContent>> GetContentAsync(IWorkflowContext context)
+        {
+            List<AIContent> content = [];
+    
+            string contentValue1 =
+                await context.FormatTemplateAsync(
+                    """
+                    {Local.TestInput}
+                    """);
+            content.Add(new TextContent(contentValue1));
+            return content;
+        }
+    
+        private AdditionalPropertiesDictionary? GetMetadata()
+        {
+            Dictionary<string, object?>? metadata = null;
+    
+            if (metadata is null)
+            {
+                return null;
+            }
+    
+            return new AdditionalPropertiesDictionary(metadata);
+        }
+    }
+    
+    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);
+        WorkflowTestRootExecutor<TInput> workflowTestRoot = new(options, inputTransform);
+        DelegateExecutor workflowTest = new(id: "workflow_test", workflowTestRoot.Session);
+        AddMessageExecutor addMessage = new(workflowTestRoot.Session, options.AgentProvider);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(workflowTestRoot);
+
+        // Connect executors
+        builder.AddEdge(workflowTestRoot, workflowTest);
+        builder.AddEdge(workflowTest, addMessage);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/AddConversationMessage.yaml

@@ -0,0 +1,15 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: workflow_test
+  actions:
+
+    - kind: AddConversationMessage
+      id: add_message
+      message: Local.MyMessage1
+      role: User
+      conversationId: =System.ConversationId
+      content:
+        - type: Text
+          value: {Local.TestInput}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/BadEmpty.yaml

@@ -0,0 +1,4 @@
+# empty yaml
+- id: 1
+- id: 2
+- id: 3

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/BadId.yaml

@@ -0,0 +1,8 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  actions:
+
+    - kind: EndConversation
+      id: end_all

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/BadKind.yaml

@@ -0,0 +1,8 @@
+kind: ToolDialog
+beginDialog:
+  kind: OnActivity
+  id: my_workflow
+  type: Message
+  actions:
+    - kind: EndConversation
+      id: end_all

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/CancelWorkflow.cs

@@ -0,0 +1,94 @@
+// ------------------------------------------------------------------------------
+// <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)
+        {
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class SendActivity1Executor(FormulaSession session) : ActionExecutor(id: "send_activity_1", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    NEVER 1!
+                    """
+                );
+            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);
+        DelegateExecutor endAll = new(id: "end_all", myWorkflowRoot.Session);
+        DelegateExecutor endAllRestart = new(id: "end_all_Restart", myWorkflowRoot.Session);
+        SendActivity1Executor sendActivity1 = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, endAll);
+        builder.AddEdge(endAllRestart, sendActivity1);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/CancelWorkflow.yaml

@@ -0,0 +1,13 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: CancelWorkflow
+      id: end_all
+
+    - kind: SendActivity
+      id: send_activity_1
+      activity: NEVER 1!

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/CaseInsensitive.yaml

@@ -0,0 +1,29 @@
+kind: WORKFLOW
+trigger:
+
+  kind: onconversationstart
+  id: my_workflow
+  actions:
+  
+    - kind: SETVARIABLE
+      id: set_input1
+      variable: Local.TestValue1
+      value: =3
+  
+    - kind: setvariable
+      id: set_input2
+      variable: Local.TestValue2
+      value: =4
+
+    - kind: ConditionGroup
+      id: condition_test
+      conditions:
+        - id: condition_match
+          condition: =Local.TestValue1 + Local.TestValue2 = 7
+          actions:
+            - kind: EndWorkflow
+              id: end_when_match
+
+    - kind: SendActivity
+      id: activity_error
+      activity: Unexpected

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ClearAllVariables.cs

@@ -0,0 +1,85 @@
+// ------------------------------------------------------------------------------
+// <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)
+        {
+        }
+    }
+    
+    /// <summary>
+    /// Reset all the state for the targeted variable scope.
+    /// </summary>
+    internal sealed class ClearAllExecutor(FormulaSession session) : ActionExecutor(id: "clear_all", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string? targetScopeName = "Local";
+            await context.QueueClearScopeAsync(targetScopeName).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);
+        ClearAllExecutor clearAll = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, clearAll);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ClearAllVariables.yaml

@@ -0,0 +1,11 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: ClearAllVariables
+      id: clear_all
+      variables: ConversationScopedVariables
+

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

@@ -0,0 +1,201 @@
+// ------------------------------------------------------------------------------
+// <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);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/Condition.yaml

@@ -0,0 +1,32 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+  
+    - kind: SetVariable
+      id: setVariable_test
+      variable: Local.TestValue
+      value: =Value(System.LastMessageText)
+
+    - kind: ConditionGroup
+      id: conditionGroup_test
+      conditions:
+        - id: conditionItem_odd
+          condition: =Mod(Local.TestValue, 2) = 1
+          actions:
+            - kind: SendActivity
+              id: sendActivity_odd
+              activity: ODD
+
+        - id: conditionItem_even
+          condition: =Mod(Local.TestValue, 2) = 0
+          actions:
+            - kind: SendActivity
+              id: sendActivity_even
+              activity: EVEN
+
+    - kind: SendActivity
+      id: activity_final
+      activity: All done!

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ConditionElse.cs

@@ -0,0 +1,193 @@
+// ------------------------------------------------------------------------------
+// <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";
+            }
+
+            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 SendactivityElseExecutor(FormulaSession session) : ActionExecutor(id: "sendActivity_else", 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 conditionGroupTestelseactions = new(id: "conditionGroup_testElseActions", myWorkflowRoot.Session);
+        DelegateExecutor conditionItemOddactions = new(id: "conditionItem_oddActions", myWorkflowRoot.Session);
+        SendactivityOddExecutor sendActivityOdd = new(myWorkflowRoot.Session);
+        DelegateExecutor conditionItemOddRestart = new(id: "conditionItem_odd_Restart", myWorkflowRoot.Session);
+        SendactivityElseExecutor sendActivityElse = 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 conditionItemOddactionsPost = new(id: "conditionItem_oddActions_Post", myWorkflowRoot.Session);
+        DelegateExecutor conditionGroupTestelseactionsPost = new(id: "conditionGroup_testElseActions_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, conditionGroupTestelseactions, (object? result) => ActionExecutor.IsMatch("conditionGroup_testElseActions", result));
+        builder.AddEdge(conditionItemOdd, conditionItemOddactions);
+        builder.AddEdge(conditionItemOddactions, sendActivityOdd);
+        builder.AddEdge(conditionItemOddRestart, conditionGroupTestelseactions);
+        builder.AddEdge(conditionGroupTestelseactions, sendActivityElse);
+        builder.AddEdge(conditionGroupTestPost, activityFinal);
+        builder.AddEdge(conditionItemOddPost, conditionGroupTestPost);
+        builder.AddEdge(sendActivityOdd, conditionItemOddactionsPost);
+        builder.AddEdge(conditionItemOddactionsPost, conditionItemOddPost);
+        builder.AddEdge(sendActivityElse, conditionGroupTestelseactionsPost);
+        builder.AddEdge(conditionGroupTestelseactionsPost, conditionGroupTestPost);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ConditionElse.yaml

@@ -0,0 +1,29 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+  
+    - kind: SetVariable
+      id: setVariable_test
+      variable: Local.TestValue
+      value: =Value(System.LastMessageText)
+
+    - kind: ConditionGroup
+      id: conditionGroup_test
+      conditions:
+        - id: conditionItem_odd
+          condition: =Mod(Local.TestValue, 2) = 1
+          actions:
+            - kind: SendActivity
+              id: sendActivity_odd
+              activity: ODD
+      elseActions:
+        - kind: SendActivity
+          id: sendActivity_else
+          activity: EVEN
+
+    - kind: SendActivity
+      id: activity_final
+      activity: All done!

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ConditionFallThrough.yaml

@@ -0,0 +1,25 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+  
+    - kind: SetVariable
+      id: setVariable_test
+      variable: Local.TestValue
+      value: =Value(System.LastMessageText)
+
+    - kind: ConditionGroup
+      id: conditionGroup_test
+      conditions:
+        - id: conditionItem_odd
+          condition: =Mod(Local.TestValue, 2) = 1
+          actions:
+            - kind: SendActivity
+              id: sendActivity_odd
+              activity: ODD
+
+    - kind: SendActivity
+      id: activity_final
+      activity: All done!

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/CopyConversationMessages.cs

@@ -0,0 +1,95 @@
+// ------------------------------------------------------------------------------
+// <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 WorkflowTestRootExecutor<TInput>(
+        DeclarativeWorkflowOptions options,
+        Func<TInput, ChatMessage> inputTransform) :
+        RootExecutor<TInput>("workflow_test_Root", options, inputTransform)
+        where TInput : notnull
+    {
+        protected override async ValueTask ExecuteAsync(TInput message, IWorkflowContext context, CancellationToken cancellationToken)
+        {
+        }
+    }
+    
+    /// <summary>
+    /// Copies one or more messages into the specified agent conversation.
+    /// </summary>
+    internal sealed class CopyMessagesExecutor(FormulaSession session, ResponseAgentProvider agentProvider) : ActionExecutor(id: "copy_messages", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string? conversationId = await context.ReadStateAsync<string>(key: "ConversationId", scopeName: "System").ConfigureAwait(false);
+            if (string.IsNullOrWhiteSpace(conversationId))
+            {
+                throw new DeclarativeActionException($"Conversation identifier must be defined: {this.Id}");
+            }
+            ChatMessage[]? messages = await context.EvaluateValueAsync<ChatMessage[]>("""[UserMessage("Hello, how can I assist you today?")]""").ConfigureAwait(false);
+            if (messages is not null)
+            {
+                foreach (ChatMessage message in messages)
+                {
+                    await agentProvider.CreateMessageAsync(conversationId, message, cancellationToken).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);
+        WorkflowTestRootExecutor<TInput> workflowTestRoot = new(options, inputTransform);
+        DelegateExecutor workflowTest = new(id: "workflow_test", workflowTestRoot.Session);
+        CopyMessagesExecutor copyMessages = new(workflowTestRoot.Session, options.AgentProvider);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(workflowTestRoot);
+
+        // Connect executors
+        builder.AddEdge(workflowTestRoot, workflowTest);
+        builder.AddEdge(workflowTest, copyMessages);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/CopyConversationMessages.yaml

@@ -0,0 +1,12 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: workflow_test
+  actions:
+
+    - kind: CopyConversationMessages
+      id: copy_messages
+      conversationId: =System.ConversationId
+      messages: =[UserMessage("Hello, how can I assist you today?")]
+

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/CreateConversation.cs

@@ -0,0 +1,88 @@
+// ------------------------------------------------------------------------------
+// <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 WorkflowTestRootExecutor<TInput>(
+        DeclarativeWorkflowOptions options,
+        Func<TInput, ChatMessage> inputTransform) :
+        RootExecutor<TInput>("workflow_test_Root", options, inputTransform)
+        where TInput : notnull
+    {
+        protected override async ValueTask ExecuteAsync(TInput message, IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            // Initialize variables
+            await context.QueueStateUpdateAsync("PrivateConversationId", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Creates a new conversation and stores the identifier value to the "Local.PrivateConversationId" variable.
+    /// </summary>
+    internal sealed class ConversationCreateExecutor(FormulaSession session, ResponseAgentProvider agentProvider) : ActionExecutor(id: "conversation_create", session)
+    {
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string conversationId = await agentProvider.CreateConversationAsync(cancellationToken).ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "PrivateConversationId", value: conversationId, scopeName: "Local").ConfigureAwait(false);
+    
+            await context.AddEventAsync(new ConversationUpdateEvent(conversationId)).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);
+        WorkflowTestRootExecutor<TInput> workflowTestRoot = new(options, inputTransform);
+        DelegateExecutor workflowTest = new(id: "workflow_test", workflowTestRoot.Session);
+        ConversationCreateExecutor conversationCreate = new(workflowTestRoot.Session, options.AgentProvider);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(workflowTestRoot);
+
+        // Connect executors
+        builder.AddEdge(workflowTestRoot, workflowTest);
+        builder.AddEdge(workflowTest, conversationCreate);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/CreateConversation.yaml

@@ -0,0 +1,10 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: workflow_test
+  actions:
+
+    - kind: CreateConversation
+      id: conversation_create
+      conversationId: Local.PrivateConversationId

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EditTable.cs

@@ -0,0 +1,87 @@
+// ------------------------------------------------------------------------------
+// <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("MyTable", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.MyTable" variable.
+    /// </summary>
+    internal sealed class SetVarExecutor(FormulaSession session) : ActionExecutor(id: "set_var", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("[{id: 3}]").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "MyTable", value: evaluatedValue, scopeName: "Local").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);
+        SetVarExecutor setVar = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, setVar);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EditTable.yaml

@@ -0,0 +1,17 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: SetVariable
+      id: set_var
+      variable: Local.MyTable
+      value: =[{id: 3}]
+
+    - kind: EditTable
+      id: edit_var
+      itemsVariable: Local.MyTable
+      changeType: Add
+      value: ={id: 7}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EditTableV2.cs

@@ -0,0 +1,87 @@
+// ------------------------------------------------------------------------------
+// <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("MyTable", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.MyTable" variable.
+    /// </summary>
+    internal sealed class SetVarExecutor(FormulaSession session) : ActionExecutor(id: "set_var", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("[{id: 3}]").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "MyTable", value: evaluatedValue, scopeName: "Local").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);
+        SetVarExecutor setVar = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, setVar);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EditTableV2.yaml

@@ -0,0 +1,18 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: SetVariable
+      id: set_var
+      variable: Local.MyTable
+      value: =[{id: 3}]
+
+    - kind: EditTableV2
+      id: edit_var
+      itemsVariable: Local.MyTable
+      changeType:
+        kind: AddItemOperation
+        value: ={id: 7}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EndConversation.cs

@@ -0,0 +1,94 @@
+// ------------------------------------------------------------------------------
+// <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)
+        {
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class SendActivity1Executor(FormulaSession session) : ActionExecutor(id: "send_activity_1", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    NEVER 1!
+                    """
+                );
+            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);
+        DelegateExecutor endAll = new(id: "end_all", myWorkflowRoot.Session);
+        DelegateExecutor endAllRestart = new(id: "end_all_Restart", myWorkflowRoot.Session);
+        SendActivity1Executor sendActivity1 = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, endAll);
+        builder.AddEdge(endAllRestart, sendActivity1);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EndConversation.yaml

@@ -0,0 +1,13 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: EndConversation
+      id: end_all
+
+    - kind: SendActivity
+      id: send_activity_1
+      activity: NEVER 1!

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EndWorkflow.cs

@@ -0,0 +1,94 @@
+// ------------------------------------------------------------------------------
+// <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)
+        {
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class SendActivity1Executor(FormulaSession session) : ActionExecutor(id: "send_activity_1", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    NEVER 1!
+                    """
+                );
+            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);
+        DelegateExecutor endAll = new(id: "end_all", myWorkflowRoot.Session);
+        DelegateExecutor endAllRestart = new(id: "end_all_Restart", myWorkflowRoot.Session);
+        SendActivity1Executor sendActivity1 = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, endAll);
+        builder.AddEdge(endAllRestart, sendActivity1);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/EndWorkflow.yaml

@@ -0,0 +1,13 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: EndWorkflow
+      id: end_all
+
+    - kind: SendActivity
+      id: send_activity_1
+      activity: NEVER 1!

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/Goto.cs

@@ -0,0 +1,143 @@
+// ------------------------------------------------------------------------------
+// <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)
+        {
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class SendActivity1Executor(FormulaSession session) : ActionExecutor(id: "send_activity_1", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    NEVER 1!
+                    """
+                );
+            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 SendActivity2Executor(FormulaSession session) : ActionExecutor(id: "send_activity_2", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    NEVER 2!
+                    """
+                );
+            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 SendActivity3Executor(FormulaSession session) : ActionExecutor(id: "send_activity_3", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    NEVER 3!
+                    """
+                );
+            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);
+        DelegateExecutor gotoEnd = new(id: "goto_end", myWorkflowRoot.Session);
+        DelegateExecutor endAll = new(id: "end_all", myWorkflowRoot.Session);
+        DelegateExecutor gotoEndRestart = new(id: "goto_end_Restart", myWorkflowRoot.Session);
+        SendActivity1Executor sendActivity1 = new(myWorkflowRoot.Session);
+        SendActivity2Executor sendActivity2 = new(myWorkflowRoot.Session);
+        SendActivity3Executor sendActivity3 = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, gotoEnd);
+        builder.AddEdge(gotoEnd, endAll);
+        builder.AddEdge(gotoEndRestart, sendActivity1);
+        builder.AddEdge(sendActivity1, sendActivity2);
+        builder.AddEdge(sendActivity2, sendActivity3);
+        builder.AddEdge(sendActivity3, endAll);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/Goto.yaml

@@ -0,0 +1,25 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: GotoAction
+      id: goto_end
+      actionId: end_all
+
+    - kind: SendActivity
+      id: send_activity_1
+      activity: NEVER 1!
+      
+    - kind: SendActivity
+      id: send_activity_2
+      activity: NEVER 2!
+
+    - kind: SendActivity
+      id: send_activity_3
+      activity: NEVER 3!
+
+    - kind: EndConversation
+      id: end_all

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/HttpRequest.yaml

@@ -0,0 +1,15 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: HttpRequestAction
+      id: http_request
+      method: GET
+      url: =Concatenate("https://api.example.test/items/", System.LastMessageText)
+      headers:
+        Accept: application/json
+      response: Local.HttpResult
+      responseHeaders: Local.HttpHeaders

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/InvokeAgent.cs

@@ -0,0 +1,112 @@
+// ------------------------------------------------------------------------------
+// <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)
+        {
+            // Set environment variables
+            await this.InitializeEnvironmentAsync(
+                context,
+                "MY_STUDENT").ConfigureAwait(false);
+    
+        }
+    }
+    
+    /// <summary>
+    /// Invokes an agent to process messages and return a response within a conversation context.
+    /// </summary>
+    internal sealed class InvokeAgentExecutor(FormulaSession session, ResponseAgentProvider agentProvider) : AgentExecutor(id: "invoke_agent", session, agentProvider)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string? agentName = await context.ReadStateAsync<string>(key: "MY_STUDENT", scopeName: "Env").ConfigureAwait(false);
+    
+            if (string.IsNullOrWhiteSpace(agentName))
+            {
+                throw new DeclarativeActionException($"Agent name must be defined: {this.Id}");
+            }
+    
+            string? conversationId = await context.ReadStateAsync<string>(key: "ConversationId", scopeName: "System").ConfigureAwait(false);
+            bool autoSend = true;
+            IList<ChatMessage>? inputMessages = await context.EvaluateListAsync<ChatMessage>("[UserMessage(System.LastMessageText)]").ConfigureAwait(false);
+    
+            AgentResponse agentResponse =
+                await InvokeAgentAsync(
+                    context,
+                    agentName,
+                    conversationId,
+                    autoSend,
+                    inputMessages,
+                    cancellationToken).ConfigureAwait(false);
+    
+            if (autoSend)
+            {
+                await context.AddEventAsync(new AgentResponseEvent(this.Id, agentResponse)).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);
+        InvokeAgentExecutor invokeAgent = new(myWorkflowRoot.Session, options.AgentProvider);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, invokeAgent);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/InvokeAgent.yaml

@@ -0,0 +1,14 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: InvokeAzureAgent
+      id: invoke_agent
+      conversationId: =System.ConversationId
+      agent:
+        name: =Env.MY_STUDENT
+      input:
+        messages: =[UserMessage(System.LastMessageText)]

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/LoopBreak.cs

@@ -0,0 +1,190 @@
+// ------------------------------------------------------------------------------
+// <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("Count", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("LoopIndex", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("LoopValue", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Loops over a list assignign the loop variable to "Local.LoopValue" variable.
+    /// </summary>
+    internal sealed class ForeachLoopExecutor(FormulaSession session) : ActionExecutor(id: "foreach_loop", session)
+    {
+        private int _index;
+        private object[] _values = [];
+    
+        public bool HasValue { get; private set; }
+    
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            this._index = 0;
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("""["a", "b", "c", "d", "e", "f"]""").ConfigureAwait(false);
+    
+            if (evaluatedValue == null)
+            {
+                this._values = [];
+                this.HasValue = false;
+            }
+            else
+            if (evaluatedValue is IEnumerable evaluatedList)
+            {
+                this._values = [.. evaluatedList];
+            }
+            else
+            {
+                this._values = [evaluatedValue];
+            }
+    
+            await this.ResetAsync(context, cancellationToken).ConfigureAwait(false);
+    
+            return default;
+        }
+    
+        public async ValueTask TakeNextAsync(IWorkflowContext context, object? _, CancellationToken cancellationToken)
+        {
+            if (this.HasValue = this._index < this._values.Length)
+            {
+                object value = this._values[this._index];
+    
+            await context.QueueStateUpdateAsync(key: "LoopValue", value: value, scopeName: "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "LoopIndex", value: this._index, scopeName: "Local").ConfigureAwait(false);
+    
+                this._index++;
+            }
+        }
+    
+        public async ValueTask CompleteAsync(IWorkflowContext context, object? _, CancellationToken cancellationToken)
+        {
+            await this.ResetAsync(context, cancellationToken).ConfigureAwait(false);
+        }
+    
+        private async ValueTask ResetAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            await context.QueueStateUpdateAsync(key: "LoopValue", value: UnassignedValue.Instance, scopeName: "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "LoopIndex", value: UnassignedValue.Instance, scopeName: "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.Count" variable.
+    /// </summary>
+    internal sealed class SetVariableInnerExecutor(FormulaSession session) : ActionExecutor(id: "set_variable_inner", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("Local.Count + 1").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "Count", value: evaluatedValue, scopeName: "Local").ConfigureAwait(false);
+    
+            return default;
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class SendActivityInnerExecutor(FormulaSession session) : ActionExecutor(id: "send_activity_inner", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    x{Local.Count} - {Local.LoopIndex}:{Local.LoopValue}
+                    """
+                );
+            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);
+        ForeachLoopExecutor foreachLoop = new(myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopNext = new(id: "foreach_loop_Next", myWorkflowRoot.Session, foreachLoop.TakeNextAsync);
+        DelegateExecutor foreachLoopPost = new(id: "foreach_loop_Post", myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopStart = new(id: "foreach_loop_Start", myWorkflowRoot.Session);
+        DelegateExecutor breakLoopNow = new(id: "break_loop_now", myWorkflowRoot.Session);
+        DelegateExecutor breakLoopNowRestart = new(id: "break_loop_now_Restart", myWorkflowRoot.Session);
+        SetVariableInnerExecutor setVariableInner = new(myWorkflowRoot.Session);
+        SendActivityInnerExecutor sendActivityInner = new(myWorkflowRoot.Session);
+        DelegateExecutor endAll = new(id: "end_all", myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopEnd = new(id: "foreach_loop_End", myWorkflowRoot.Session, foreachLoop.CompleteAsync);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, foreachLoop);
+        builder.AddEdge(foreachLoop, foreachLoopNext);
+        builder.AddEdge(foreachLoopNext, foreachLoopPost, (object? result) => !foreachLoop.HasValue);
+        builder.AddEdge(foreachLoopNext, foreachLoopStart, (object? result) => foreachLoop.HasValue);
+        builder.AddEdge(foreachLoopStart, breakLoopNow);
+        builder.AddEdge(breakLoopNow, foreachLoopPost);
+        builder.AddEdge(breakLoopNowRestart, setVariableInner);
+        builder.AddEdge(setVariableInner, sendActivityInner);
+        builder.AddEdge(foreachLoopPost, endAll);
+        builder.AddEdge(sendActivityInner, foreachLoopEnd);
+        builder.AddEdge(foreachLoopEnd, foreachLoopNext);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/LoopBreak.yaml

@@ -0,0 +1,28 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: Foreach
+      id: foreach_loop
+      items: =["a", "b", "c", "d", "e", "f"]
+      index: Local.LoopIndex
+      value: Local.LoopValue
+      actions:
+
+        - kind: BreakLoop
+          id: break_loop_now
+
+        - kind: SetVariable
+          id: set_variable_inner
+          variable: Local.Count
+          value: =Local.Count + 1
+
+        - kind: SendActivity
+          id: send_activity_inner
+          activity: x{Local.Count} - {Local.LoopIndex}:{Local.LoopValue}
+
+    - kind: EndConversation
+      id: end_all

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/LoopContinue.cs

@@ -0,0 +1,190 @@
+// ------------------------------------------------------------------------------
+// <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("Count", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("LoopIndex", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("LoopValue", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Loops over a list assignign the loop variable to "Local.LoopValue" variable.
+    /// </summary>
+    internal sealed class ForeachLoopExecutor(FormulaSession session) : ActionExecutor(id: "foreach_loop", session)
+    {
+        private int _index;
+        private object[] _values = [];
+    
+        public bool HasValue { get; private set; }
+    
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            this._index = 0;
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("""["a", "b", "c", "d", "e", "f"]""").ConfigureAwait(false);
+    
+            if (evaluatedValue == null)
+            {
+                this._values = [];
+                this.HasValue = false;
+            }
+            else
+            if (evaluatedValue is IEnumerable evaluatedList)
+            {
+                this._values = [.. evaluatedList];
+            }
+            else
+            {
+                this._values = [evaluatedValue];
+            }
+    
+            await this.ResetAsync(context, cancellationToken).ConfigureAwait(false);
+    
+            return default;
+        }
+    
+        public async ValueTask TakeNextAsync(IWorkflowContext context, object? _, CancellationToken cancellationToken)
+        {
+            if (this.HasValue = this._index < this._values.Length)
+            {
+                object value = this._values[this._index];
+    
+            await context.QueueStateUpdateAsync(key: "LoopValue", value: value, scopeName: "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "LoopIndex", value: this._index, scopeName: "Local").ConfigureAwait(false);
+    
+                this._index++;
+            }
+        }
+    
+        public async ValueTask CompleteAsync(IWorkflowContext context, object? _, CancellationToken cancellationToken)
+        {
+            await this.ResetAsync(context, cancellationToken).ConfigureAwait(false);
+        }
+    
+        private async ValueTask ResetAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            await context.QueueStateUpdateAsync(key: "LoopValue", value: UnassignedValue.Instance, scopeName: "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "LoopIndex", value: UnassignedValue.Instance, scopeName: "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.Count" variable.
+    /// </summary>
+    internal sealed class SetVariableInnerExecutor(FormulaSession session) : ActionExecutor(id: "set_variable_inner", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("Local.Count + 1").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "Count", value: evaluatedValue, scopeName: "Local").ConfigureAwait(false);
+    
+            return default;
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class SendActivityInnerExecutor(FormulaSession session) : ActionExecutor(id: "send_activity_inner", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    x{Local.Count} - {Local.LoopIndex}:{Local.LoopValue}
+                    """
+                );
+            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);
+        ForeachLoopExecutor foreachLoop = new(myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopNext = new(id: "foreach_loop_Next", myWorkflowRoot.Session, foreachLoop.TakeNextAsync);
+        DelegateExecutor foreachLoopPost = new(id: "foreach_loop_Post", myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopStart = new(id: "foreach_loop_Start", myWorkflowRoot.Session);
+        DelegateExecutor continueLoopNow = new(id: "continue_loop_now", myWorkflowRoot.Session);
+        DelegateExecutor continueLoopNowRestart = new(id: "continue_loop_now_Restart", myWorkflowRoot.Session);
+        SetVariableInnerExecutor setVariableInner = new(myWorkflowRoot.Session);
+        SendActivityInnerExecutor sendActivityInner = new(myWorkflowRoot.Session);
+        DelegateExecutor endAll = new(id: "end_all", myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopEnd = new(id: "foreach_loop_End", myWorkflowRoot.Session, foreachLoop.CompleteAsync);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, foreachLoop);
+        builder.AddEdge(foreachLoop, foreachLoopNext);
+        builder.AddEdge(foreachLoopNext, foreachLoopPost, (object? result) => !foreachLoop.HasValue);
+        builder.AddEdge(foreachLoopNext, foreachLoopStart, (object? result) => foreachLoop.HasValue);
+        builder.AddEdge(foreachLoopStart, continueLoopNow);
+        builder.AddEdge(continueLoopNow, foreachLoopStart);
+        builder.AddEdge(continueLoopNowRestart, setVariableInner);
+        builder.AddEdge(setVariableInner, sendActivityInner);
+        builder.AddEdge(foreachLoopPost, endAll);
+        builder.AddEdge(sendActivityInner, foreachLoopEnd);
+        builder.AddEdge(foreachLoopEnd, foreachLoopNext);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/LoopContinue.yaml

@@ -0,0 +1,28 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: Foreach
+      id: foreach_loop
+      items: =["a", "b", "c", "d", "e", "f"]
+      index: Local.LoopIndex
+      value: Local.LoopValue
+      actions:
+
+        - kind: ContinueLoop
+          id: continue_loop_now
+
+        - kind: SetVariable
+          id: set_variable_inner
+          variable: Local.Count
+          value: =Local.Count + 1
+
+        - kind: SendActivity
+          id: send_activity_inner
+          activity: x{Local.Count} - {Local.LoopIndex}:{Local.LoopValue}
+
+    - kind: EndConversation
+      id: end_all

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/LoopEach.cs

@@ -0,0 +1,186 @@
+// ------------------------------------------------------------------------------
+// <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("Count", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("LoopIndex", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("LoopValue", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Loops over a list assignign the loop variable to "Local.LoopValue" variable.
+    /// </summary>
+    internal sealed class ForeachLoopExecutor(FormulaSession session) : ActionExecutor(id: "foreach_loop", session)
+    {
+        private int _index;
+        private object[] _values = [];
+    
+        public bool HasValue { get; private set; }
+    
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            this._index = 0;
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("""["a", "b", "c", "d", "e", "f"]""").ConfigureAwait(false);
+    
+            if (evaluatedValue == null)
+            {
+                this._values = [];
+                this.HasValue = false;
+            }
+            else
+            if (evaluatedValue is IEnumerable evaluatedList)
+            {
+                this._values = [.. evaluatedList];
+            }
+            else
+            {
+                this._values = [evaluatedValue];
+            }
+    
+            await this.ResetAsync(context, cancellationToken).ConfigureAwait(false);
+    
+            return default;
+        }
+    
+        public async ValueTask TakeNextAsync(IWorkflowContext context, object? _, CancellationToken cancellationToken)
+        {
+            if (this.HasValue = this._index < this._values.Length)
+            {
+                object value = this._values[this._index];
+    
+            await context.QueueStateUpdateAsync(key: "LoopValue", value: value, scopeName: "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "LoopIndex", value: this._index, scopeName: "Local").ConfigureAwait(false);
+    
+                this._index++;
+            }
+        }
+    
+        public async ValueTask CompleteAsync(IWorkflowContext context, object? _, CancellationToken cancellationToken)
+        {
+            await this.ResetAsync(context, cancellationToken).ConfigureAwait(false);
+        }
+    
+        private async ValueTask ResetAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            await context.QueueStateUpdateAsync(key: "LoopValue", value: UnassignedValue.Instance, scopeName: "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "LoopIndex", value: UnassignedValue.Instance, scopeName: "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.Count" variable.
+    /// </summary>
+    internal sealed class SetVariableInnerExecutor(FormulaSession session) : ActionExecutor(id: "set_variable_inner", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("Local.Count + 1").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "Count", value: evaluatedValue, scopeName: "Local").ConfigureAwait(false);
+    
+            return default;
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class SendActivityInnerExecutor(FormulaSession session) : ActionExecutor(id: "send_activity_inner", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    x{Local.Count} - {Local.LoopIndex}:{Local.LoopValue}
+                    """
+                );
+            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);
+        ForeachLoopExecutor foreachLoop = new(myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopNext = new(id: "foreach_loop_Next", myWorkflowRoot.Session, foreachLoop.TakeNextAsync);
+        DelegateExecutor foreachLoopPost = new(id: "foreach_loop_Post", myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopStart = new(id: "foreach_loop_Start", myWorkflowRoot.Session);
+        SetVariableInnerExecutor setVariableInner = new(myWorkflowRoot.Session);
+        SendActivityInnerExecutor sendActivityInner = new(myWorkflowRoot.Session);
+        DelegateExecutor endAll = new(id: "end_all", myWorkflowRoot.Session);
+        DelegateExecutor foreachLoopEnd = new(id: "foreach_loop_End", myWorkflowRoot.Session, foreachLoop.CompleteAsync);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, foreachLoop);
+        builder.AddEdge(foreachLoop, foreachLoopNext);
+        builder.AddEdge(foreachLoopNext, foreachLoopPost, (object? result) => !foreachLoop.HasValue);
+        builder.AddEdge(foreachLoopNext, foreachLoopStart, (object? result) => foreachLoop.HasValue);
+        builder.AddEdge(foreachLoopStart, setVariableInner);
+        builder.AddEdge(setVariableInner, sendActivityInner);
+        builder.AddEdge(foreachLoopPost, endAll);
+        builder.AddEdge(sendActivityInner, foreachLoopEnd);
+        builder.AddEdge(foreachLoopEnd, foreachLoopNext);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/LoopEach.yaml

@@ -0,0 +1,25 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: Foreach
+      id: foreach_loop
+      items: =["a", "b", "c", "d", "e", "f"]
+      index: Local.LoopIndex
+      value: Local.LoopValue
+      actions:
+
+        - kind: SetVariable
+          id: set_variable_inner
+          variable: Local.Count
+          value: =Local.Count + 1
+
+        - kind: SendActivity
+          id: send_activity_inner
+          activity: x{Local.Count} - {Local.LoopIndex}:{Local.LoopValue}
+
+    - kind: EndConversation
+      id: end_all

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/MixedScopes.yaml

@@ -0,0 +1,16 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+  
+    - kind: SetVariable
+      id: set_input
+      variable: Topic.TestValue
+      value: =System.LastMessageText
+
+    - kind: SendActivity
+      id: activity_input
+      activity: |-
+        Input: "{Local.TestValue}"

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ParseValue.cs

@@ -0,0 +1,106 @@
+// ------------------------------------------------------------------------------
+// <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("MySource", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("MyVar", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.MySource" variable.
+    /// </summary>
+    internal sealed class SetVarExecutor(FormulaSession session) : ActionExecutor(id: "set_var", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = "42";
+            await context.QueueStateUpdateAsync(key: "MySource", value: evaluatedValue, scopeName: "Local").ConfigureAwait(false);
+    
+            return default;
+        }
+    }
+    
+    /// <summary>
+    /// Parses a string or untyped value to the provided data type. When the input is a string, it will be treated as JSON.
+    /// </summary>
+    internal sealed class ParseVarExecutor(FormulaSession session) : ActionExecutor(id: "parse_var", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            VariableType targetType = typeof(decimal);
+            object? parsedValue = await context.ConvertValueAsync(targetType, key: "MySource", scopeName: "Local", cancellationToken).ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "MyVar", value: parsedValue, scopeName: "Local").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);
+        SetVarExecutor setVar = new(myWorkflowRoot.Session);
+        ParseVarExecutor parseVar = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, setVar);
+        builder.AddEdge(setVar, parseVar);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ParseValue.yaml

@@ -0,0 +1,17 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+
+  actions:
+    - kind: SetVariable
+      id: set_var
+      variable: Local.MySource
+      value: "42"
+
+    - kind: ParseValue
+      id: parse_var
+      variable: Local.MyVar
+      value: =Local.MySource
+      valueType: Number

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ParseValueList.yaml

@@ -0,0 +1,17 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+
+  actions:
+    - kind: SetVariable
+      id: set_var
+      variable: Local.MySource
+      value: '["apple","banana","cat"]'
+
+    - kind: ParseValue
+      id: parse_var
+      variable: Local.MyVar
+      value: =Local.MySource
+      valueType: Table

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ResetVariable.cs

@@ -0,0 +1,103 @@
+// ------------------------------------------------------------------------------
+// <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("MyVar", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.MyVar" variable.
+    /// </summary>
+    internal sealed class SetVarExecutor(FormulaSession session) : ActionExecutor(id: "set_var", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = 42;
+            await context.QueueStateUpdateAsync(key: "MyVar", value: evaluatedValue, scopeName: "Local").ConfigureAwait(false);
+    
+            return default;
+        }
+    }
+    
+    /// <summary>
+    /// Resets the value of the "Local.MyVar" variable, potentially causing re-evaluation
+    /// of the default value, question or action that provides the value to this variable.
+    /// </summary>
+    internal sealed class ClearVarExecutor(FormulaSession session) : ActionExecutor(id: "clear_var", session)
+    {
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            await context.QueueStateUpdateAsync(key: "MyVar", value: UnassignedValue.Instance, scopeName: "Local").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);
+        SetVarExecutor setVar = new(myWorkflowRoot.Session);
+        ClearVarExecutor clearVar = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, setVar);
+        builder.AddEdge(setVar, clearVar);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/ResetVariable.yaml

@@ -0,0 +1,15 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: SetVariable
+      id: set_var
+      variable: Local.MyVar
+      value: 42
+    - kind: ResetVariable
+      id: clear_var
+      variable: Local.MyVar
+  

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/RetrieveConversationMessage.cs

@@ -0,0 +1,91 @@
+// ------------------------------------------------------------------------------
+// <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 WorkflowTestRootExecutor<TInput>(
+        DeclarativeWorkflowOptions options,
+        Func<TInput, ChatMessage> inputTransform) :
+        RootExecutor<TInput>("workflow_test_Root", options, inputTransform)
+        where TInput : notnull
+    {
+        protected override async ValueTask ExecuteAsync(TInput message, IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            // Initialize variables
+            await context.QueueStateUpdateAsync("MyMessage1Copy", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("MyMessageId", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync("PrivateConversationId", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Retrieves a list of messages from an agent conversation.
+    /// </summary>
+    internal sealed class GetMessageSingleExecutor(FormulaSession session, ResponseAgentProvider agentProvider) : ActionExecutor(id: "get_message_single", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string conversationId = await context.ReadStateAsync<string>(key: "PrivateConversationId", scopeName: "Local").ConfigureAwait(false);
+            string messageId = await context.ReadStateAsync<string>(key: "MyMessageId", scopeName: "Local").ConfigureAwait(false);
+            ChatMessage message = await agentProvider.GetMessageAsync(conversationId, messageId, cancellationToken).ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "MyMessage1Copy", value: message, scopeName: "Local").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);
+        WorkflowTestRootExecutor<TInput> workflowTestRoot = new(options, inputTransform);
+        DelegateExecutor workflowTest = new(id: "workflow_test", workflowTestRoot.Session);
+        GetMessageSingleExecutor getMessageSingle = new(workflowTestRoot.Session, options.AgentProvider);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(workflowTestRoot);
+
+        // Connect executors
+        builder.AddEdge(workflowTestRoot, workflowTest);
+        builder.AddEdge(workflowTest, getMessageSingle);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/RetrieveConversationMessage.yaml

@@ -0,0 +1,12 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: workflow_test
+  actions:
+
+    - kind: RetrieveConversationMessage
+      id: get_message_single
+      message: Local.MyMessage1Copy
+      conversationId: =Local.PrivateConversationId
+      messageId: =Local.MyMessageId

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/RetrieveConversationMessages.cs

@@ -0,0 +1,104 @@
+// ------------------------------------------------------------------------------
+// <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 WorkflowTestRootExecutor<TInput>(
+        DeclarativeWorkflowOptions options,
+        Func<TInput, ChatMessage> inputTransform) :
+        RootExecutor<TInput>("workflow_test_Root", options, inputTransform)
+        where TInput : notnull
+    {
+        protected override async ValueTask ExecuteAsync(TInput message, IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            // Initialize variables
+            await context.QueueStateUpdateAsync("AllMessages", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Retrieves a specific message from an agent conversation.
+    /// </summary>
+    internal sealed class GetMessagesAllExecutor(FormulaSession session, ResponseAgentProvider agentProvider) : ActionExecutor(id: "get_messages_all", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string conversationId = await context.ReadStateAsync<string>(key: "ConversationId", scopeName: "System").ConfigureAwait(false);
+            int limit = 20;
+            string? after = null;
+            string? before = null;
+            bool newestFirst = false;
+            IAsyncEnumerable<ChatMessage> messagesResult =
+                agentProvider.GetMessagesAsync(
+                    conversationId,
+                    limit,
+                    after,
+                    before,
+                    newestFirst,
+                    cancellationToken);
+            List<ChatMessage> messages = [];
+            await foreach (ChatMessage message in messagesResult.ConfigureAwait(false))
+            {
+                messages.Add(message);
+            }
+            await context.QueueStateUpdateAsync(key: "AllMessages", value: messages, scopeName: "Local").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);
+        WorkflowTestRootExecutor<TInput> workflowTestRoot = new(options, inputTransform);
+        DelegateExecutor workflowTest = new(id: "workflow_test", workflowTestRoot.Session);
+        GetMessagesAllExecutor getMessagesAll = new(workflowTestRoot.Session, options.AgentProvider);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(workflowTestRoot);
+
+        // Connect executors
+        builder.AddEdge(workflowTestRoot, workflowTest);
+        builder.AddEdge(workflowTest, getMessagesAll);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/RetrieveConversationMessages.yaml

@@ -0,0 +1,11 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: workflow_test
+  actions:
+  
+    - kind: RetrieveConversationMessages
+      id: get_messages_all
+      messages: Local.AllMessages
+      conversationId: =System.ConversationId

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/SendActivity.cs

@@ -0,0 +1,110 @@
+// ------------------------------------------------------------------------------
+// <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 SetInputExecutor(FormulaSession session) : ActionExecutor(id: "set_input", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = await context.ReadStateAsync<object>(key: "LastMessageText", scopeName: "System").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "TestValue", value: evaluatedValue, scopeName: "Local").ConfigureAwait(false);
+    
+            return default;
+        }
+    }
+    
+    /// <summary>
+    /// Formats a message template and sends an activity event.
+    /// </summary>
+    internal sealed class ActivityInputExecutor(FormulaSession session) : ActionExecutor(id: "activity_input", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string activityText =
+                await context.FormatTemplateAsync(
+                    """
+                    Input: "{Local.TestValue}"
+                    """
+                );
+            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);
+        SetInputExecutor setInput = new(myWorkflowRoot.Session);
+        ActivityInputExecutor activityInput = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, setInput);
+        builder.AddEdge(setInput, activityInput);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/SendActivity.yaml

@@ -0,0 +1,16 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+  
+    - kind: SetVariable
+      id: set_input
+      variable: Local.TestValue
+      value: =System.LastMessageText
+
+    - kind: SendActivity
+      id: activity_input
+      activity: |-
+        Input: "{Local.TestValue}"

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/SetTextVariable.cs

@@ -0,0 +1,90 @@
+// ------------------------------------------------------------------------------
+// <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("TestVar", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated message template to the "Local.TestVar" variable.
+    /// </summary>
+    internal sealed class SetTextExecutor(FormulaSession session) : ActionExecutor(id: "set_text", session)
+    {
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            string textValue =
+                await context.FormatTemplateAsync(
+                    """
+                    Test content
+                    """);
+            await context.QueueStateUpdateAsync(key: "TestVar", value: textValue, scopeName: "Local").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);
+        SetTextExecutor setText = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, setText);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/SetTextVariable.yaml

@@ -0,0 +1,11 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: SetTextVariable
+      id: set_text
+      variable: Local.TestVar
+      value: Test content

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/SetVariable.cs

@@ -0,0 +1,87 @@
+// ------------------------------------------------------------------------------
+// <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("TestVar", UnassignedValue.Instance, "Local").ConfigureAwait(false);
+        }
+    }
+    
+    /// <summary>
+    /// Assigns an evaluated expression, other variable, or literal value to the  "Local.TestVar" variable.
+    /// </summary>
+    internal sealed class SetVarExecutor(FormulaSession session) : ActionExecutor(id: "set_var", session)
+    {
+        // <inheritdoc />
+        protected override async ValueTask<object?> ExecuteAsync(IWorkflowContext context, CancellationToken cancellationToken)
+        {
+            object? evaluatedValue = await context.EvaluateValueAsync<object>("3").ConfigureAwait(false);
+            await context.QueueStateUpdateAsync(key: "TestVar", value: evaluatedValue, scopeName: "Local").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);
+        SetVarExecutor setVar = new(myWorkflowRoot.Session);
+
+        // Define the workflow builder
+        WorkflowBuilder builder = new(myWorkflowRoot);
+
+        // Connect executors
+        builder.AddEdge(myWorkflowRoot, myWorkflow);
+        builder.AddEdge(myWorkflow, setVar);
+
+        // Build the workflow
+        return builder.Build(validateOrphans: false);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Workflows/SetVariable.yaml

@@ -0,0 +1,11 @@
+kind: Workflow
+trigger:
+
+  kind: OnConversationStart
+  id: my_workflow
+  actions:
+
+    - kind: SetVariable
+      id: set_var
+      variable: Local.TestVar
+      value: =3