.NET: Rename workflows projects (#975)

* Renaming Microsoft.Agent.Workflows to Microsoft.Agents.AI.Workflows

* Removing local settings.

* Removing remining old files from merge.

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/ObjectModel/ClearAllVariablesExecutorTest.cs

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.ObjectModel;
+using Microsoft.Bot.ObjectModel;
+using Microsoft.PowerFx.Types;
+using Xunit.Abstractions;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+
+/// <summary>
+/// Tests for <see cref="ClearAllVariablesExecutor"/>.
+/// </summary>
+public sealed class ClearAllVariablesExecutorTest(ITestOutputHelper output) : WorkflowActionExecutorTest(output)
+{
+    [Fact]
+    public async Task ClearWorkflowScopeAsync()
+    {
+        // Arrange
+        this.State.Set("NoVar", FormulaValue.New("Old value"));
+        this.State.Bind();
+
+        ClearAllVariables model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ClearWorkflowScopeAsync)),
+                VariablesToClear.ConversationScopedVariables);
+
+        // Act
+        ClearAllVariablesExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyUndefined("NoVar");
+    }
+
+    [Fact]
+    public async Task ClearUndefinedScopeAsync()
+    {
+        // Arrange
+        this.State.Set("NoVar", FormulaValue.New("Old value"));
+        this.State.Bind();
+
+        // Arrange
+        ClearAllVariables model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ClearUndefinedScopeAsync)),
+                VariablesToClear.UserScopedVariables);
+
+        // Act
+        ClearAllVariablesExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState("NoVar", FormulaValue.New("Old value"));
+    }
+
+    private ClearAllVariables CreateModel(string displayName, VariablesToClear variableTarget)
+    {
+        ClearAllVariables.Builder actionBuilder =
+            new()
+            {
+                Id = this.CreateActionId(),
+                DisplayName = this.FormatDisplayName(displayName),
+                Variables = EnumExpression<VariablesToClearWrapper>.Literal(VariablesToClearWrapper.Get(variableTarget)),
+            };
+
+        return AssignParent<ClearAllVariables>(actionBuilder);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/ObjectModel/ParseValueExecutorTest.cs

@@ -0,0 +1,114 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.ObjectModel;
+using Microsoft.Bot.ObjectModel;
+using Microsoft.PowerFx.Types;
+using Xunit.Abstractions;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+
+/// <summary>
+/// Tests for <see cref="ParseValueExecutor"/>.
+/// </summary>
+public sealed class ParseValueExecutorTest(ITestOutputHelper output) : WorkflowActionExecutorTest(output)
+{
+    [Fact]
+    public async Task ParseTableAsync()
+    {
+        // Arrange
+        RecordDataType.Builder recordBuilder =
+            new()
+            {
+                Properties =
+                {
+                    {"key1", new PropertyInfo.Builder() { Type = DataType.String } },
+                }
+            };
+        ParseValue model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ParseTableAsync)),
+                recordBuilder,
+                @"{ ""key1"": ""val1"" }");
+
+        // Act
+        ParseValueExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState("Target", FormulaValue.NewRecordFromFields(new NamedValue("key1", FormulaValue.New("val1"))));
+    }
+
+    [Fact]
+    public async Task ParseBooleanAsync()
+    {
+        // Arrange
+        ParseValue model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ParseTableAsync)),
+                new BooleanDataType.Builder(),
+                "True");
+
+        // Act
+        ParseValueExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState("Target", FormulaValue.New(true));
+    }
+
+    [Fact]
+    public async Task ParseNumberAsync()
+    {
+        // Arrange
+        ParseValue model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ParseNumberAsync)),
+                new NumberDataType.Builder(),
+                "42");
+
+        // Act
+        ParseValueExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState("Target", FormulaValue.New(42));
+    }
+
+    [Fact]
+    public async Task ParseStringAsync()
+    {
+        // Arrange
+        ParseValue model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ParseStringAsync)),
+                new StringDataType.Builder(),
+                "Hello, World!");
+
+        // Act
+        ParseValueExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState("Target", FormulaValue.New("Hello, World!"));
+    }
+
+    private ParseValue CreateModel(string displayName, DataType.Builder typeBuilder, string sourceText)
+    {
+        ParseValue.Builder actionBuilder =
+            new()
+            {
+                Id = this.CreateActionId(),
+                DisplayName = this.FormatDisplayName(displayName),
+                ValueType = typeBuilder,
+                Variable = PropertyPath.TopicVariable("Target"),
+                Value = new ValueExpression.Builder(ValueExpression.Literal(StringDataValue.Create(sourceText))),
+            };
+
+        return AssignParent<ParseValue>(actionBuilder);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/ObjectModel/ResetVariableExecutorTest.cs

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.ObjectModel;
+using Microsoft.Bot.ObjectModel;
+using Microsoft.PowerFx.Types;
+using Xunit.Abstractions;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+
+/// <summary>
+/// Tests for <see cref="ResetVariableExecutor"/>.
+/// </summary>
+public sealed class ResetVariableExecutorTest(ITestOutputHelper output) : WorkflowActionExecutorTest(output)
+{
+    [Fact]
+    public async Task ResetDefinedValueAsync()
+    {
+        // Arrange
+        this.State.Set("MyVar1", FormulaValue.New("Value #1"));
+        this.State.Set("MyVar2", FormulaValue.New("Value #2"));
+
+        ResetVariable model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ResetDefinedValueAsync)),
+                FormatVariablePath("MyVar1"));
+
+        // Act
+        ResetVariableExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyUndefined("MyVar1");
+        this.VerifyState("MyVar2", FormulaValue.New("Value #2"));
+    }
+
+    [Fact]
+    public async Task ResetUndefinedValueAsync()
+    {
+        // Arrange
+        this.State.Set("MyVar1", FormulaValue.New("Value #1"));
+
+        ResetVariable model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(ResetUndefinedValueAsync)),
+                FormatVariablePath("NoVar"));
+
+        // Act
+        ResetVariableExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyUndefined("NoVar");
+        this.VerifyState("MyVar1", FormulaValue.New("Value #1"));
+    }
+
+    private ResetVariable CreateModel(string displayName, string variablePath)
+    {
+        ResetVariable.Builder actionBuilder =
+            new()
+            {
+                Id = this.CreateActionId(),
+                DisplayName = this.FormatDisplayName(displayName),
+                Variable = InitializablePropertyPath.Create(variablePath),
+            };
+
+        return AssignParent<ResetVariable>(actionBuilder);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/ObjectModel/SendActivityExecutorTest.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.ObjectModel;
+using Microsoft.Bot.ObjectModel;
+using Xunit.Abstractions;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+
+/// <summary>
+/// Tests for <see cref="SendActivityExecutor"/>.
+/// </summary>
+public sealed class SendActivityExecutorTest(ITestOutputHelper output) : WorkflowActionExecutorTest(output)
+{
+    [Fact]
+    public async Task CaptureActivityAsync()
+    {
+        // Arrange
+        SendActivity model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(CaptureActivityAsync)),
+                "Test activity message");
+
+        // Act
+        SendActivityExecutor action = new(model, this.State);
+        WorkflowEvent[] events = await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        Assert.Contains(events, e => e is MessageActivityEvent);
+    }
+
+    private SendActivity CreateModel(string displayName, string activityMessage, string? summary = null)
+    {
+        MessageActivityTemplate.Builder activityBuilder =
+            new()
+            {
+                Summary = summary,
+                Text = { TemplateLine.Parse(activityMessage) },
+            };
+        SendActivity.Builder actionBuilder =
+            new()
+            {
+                Id = this.CreateActionId(),
+                DisplayName = this.FormatDisplayName(displayName),
+                Activity = activityBuilder.Build(),
+            };
+
+        return AssignParent<SendActivity>(actionBuilder);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/ObjectModel/SetTextVariableExecutorTest.cs

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.ObjectModel;
+using Microsoft.Bot.ObjectModel;
+using Microsoft.PowerFx.Types;
+using Xunit.Abstractions;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+
+/// <summary>
+/// Tests for <see cref="SetTextVariableExecutor"/>.
+/// </summary>
+public sealed class SetTextVariableExecutorTest(ITestOutputHelper output) : WorkflowActionExecutorTest(output)
+{
+    [Fact]
+    public async Task SetLiteralValueAsync()
+    {
+        // Arrange
+        SetTextVariable model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(SetLiteralValueAsync)),
+                FormatVariablePath("TextVar"),
+                "Text variable value");
+
+        // Act
+        SetTextVariableExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState("TextVar", FormulaValue.New("Text variable value"));
+    }
+
+    [Fact]
+    public async Task UpdateExistingValueAsync()
+    {
+        // Arrange
+        this.State.Set("TextVar", FormulaValue.New("Old value"));
+
+        SetTextVariable model =
+            this.CreateModel(
+                this.FormatDisplayName(nameof(UpdateExistingValueAsync)),
+                FormatVariablePath("TextVar"),
+                "New value");
+
+        // Act
+        SetTextVariableExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState("TextVar", FormulaValue.New("New value"));
+    }
+
+    private SetTextVariable CreateModel(string displayName, string variablePath, string textValue)
+    {
+        SetTextVariable.Builder actionBuilder =
+            new()
+            {
+                Id = this.CreateActionId(),
+                DisplayName = this.FormatDisplayName(displayName),
+                Variable = InitializablePropertyPath.Create(variablePath),
+                Value = TemplateLine.Parse(textValue),
+            };
+
+        return AssignParent<SetTextVariable>(actionBuilder);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/ObjectModel/SetVariableExecutorTest.cs

@@ -0,0 +1,205 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.ObjectModel;
+using Microsoft.Bot.ObjectModel;
+using Microsoft.PowerFx.Types;
+using Xunit.Abstractions;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+
+/// <summary>
+/// Tests for <see cref="SetVariableExecutor"/>.
+/// </summary>
+public sealed class SetVariableExecutorTest(ITestOutputHelper output) : WorkflowActionExecutorTest(output)
+{
+    [Fact]
+    public void InvalidModel() =>
+        // Arrange, Act, Assert
+        Assert.Throws<DeclarativeModelException>(() => new SetVariableExecutor(new SetVariable(), this.State));
+
+    [Fact]
+    public async Task SetNumericValueAsync() =>
+        // Arrange, Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetNumericValueAsync),
+            variableName: "TestVariable",
+            variableValue: new NumberDataValue(42),
+            expectedValue: FormulaValue.New(42));
+
+    [Fact]
+    public async Task SetStringValueAsync() =>
+        // Arrange, Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetStringValueAsync),
+            variableName: "TestVariable",
+            variableValue: new StringDataValue("Text"),
+            expectedValue: FormulaValue.New("Text"));
+
+    [Fact]
+    public async Task SetBooleanValueAsync() =>
+        // Arrange, Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetBooleanValueAsync),
+            variableName: "TestVariable",
+            variableValue: new BooleanDataValue(true),
+            expectedValue: FormulaValue.New(true));
+
+    [Fact]
+    public async Task SetBooleanExpressionAsync()
+    {
+        // Arrange
+        ValueExpression.Builder expressionBuilder = new(ValueExpression.Expression("true || false"));
+
+        // Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetBooleanExpressionAsync),
+            variableName: "TestVariable",
+            valueExpression: expressionBuilder,
+            expectedValue: FormulaValue.New(true));
+    }
+
+    [Fact]
+    public async Task SetNumberExpressionAsync()
+    {
+        // Arrange
+        ValueExpression.Builder expressionBuilder = new(ValueExpression.Expression("9 - 3"));
+
+        // Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetBooleanExpressionAsync),
+            variableName: "TestVariable",
+            valueExpression: expressionBuilder,
+            expectedValue: FormulaValue.New(6));
+    }
+
+    [Fact]
+    public async Task SetStringExpressionAsync()
+    {
+        // Arrange
+        ValueExpression.Builder expressionBuilder = new(ValueExpression.Expression(@"Concatenate(""A"", ""B"", ""C"")"));
+
+        // Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetBooleanExpressionAsync),
+            variableName: "TestVariable",
+            valueExpression: expressionBuilder,
+            expectedValue: FormulaValue.New("ABC"));
+    }
+
+    [Fact]
+    public async Task SetBooleanVariableAsync()
+    {
+        // Arrange
+        this.State.Set("Source", FormulaValue.New(true));
+        this.State.Bind();
+
+        ValueExpression.Builder expressionBuilder = new(ValueExpression.Variable(PropertyPath.TopicVariable("Source")));
+
+        // Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetBooleanExpressionAsync),
+            variableName: "TestVariable",
+            valueExpression: expressionBuilder,
+            expectedValue: FormulaValue.New(true));
+    }
+
+    [Fact]
+    public async Task SetNumberVariableAsync()
+    {
+        // Arrange
+        this.State.Set("Source", FormulaValue.New(321));
+        this.State.Bind();
+
+        ValueExpression.Builder expressionBuilder = new(ValueExpression.Variable(PropertyPath.TopicVariable("Source")));
+
+        // Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetBooleanExpressionAsync),
+            variableName: "TestVariable",
+            valueExpression: expressionBuilder,
+            expectedValue: FormulaValue.New(321));
+    }
+
+    [Fact]
+    public async Task SetStringVariableAsync()
+    {
+        // Arrange
+        this.State.Set("Source", FormulaValue.New("Test"));
+        this.State.Bind();
+
+        ValueExpression.Builder expressionBuilder = new(ValueExpression.Variable(PropertyPath.TopicVariable("Source")));
+
+        // Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(SetBooleanExpressionAsync),
+            variableName: "TestVariable",
+            valueExpression: expressionBuilder,
+            expectedValue: FormulaValue.New("Test"));
+    }
+
+    [Fact]
+    public async Task UpdateExistingValueAsync()
+    {
+        // Arrange
+        this.State.Set("VarA", FormulaValue.New(33));
+
+        // Act, Assert
+        await this.ExecuteTestAsync(
+            displayName: nameof(UpdateExistingValueAsync),
+            variableName: "VarA",
+            variableValue: new NumberDataValue(42),
+            expectedValue: FormulaValue.New(42));
+    }
+
+    private Task ExecuteTestAsync(
+        string displayName,
+        string variableName,
+        DataValue variableValue,
+        FormulaValue expectedValue)
+    {
+        // Arrange
+        ValueExpression.Builder expressionBuilder = new(ValueExpression.Literal(variableValue));
+
+        // Act & Assert
+        return this.ExecuteTestAsync(displayName, variableName, expressionBuilder, expectedValue);
+    }
+
+    private async Task ExecuteTestAsync(
+        string displayName,
+        string variableName,
+        ValueExpression.Builder valueExpression,
+        FormulaValue expectedValue)
+    {
+        // Arrange
+        SetVariable model =
+            this.CreateModel(
+                displayName,
+                FormatVariablePath(variableName),
+                valueExpression);
+
+        this.State.Set(variableName, FormulaValue.New(33));
+
+        // Act
+        SetVariableExecutor action = new(model, this.State);
+        await this.ExecuteAsync(action);
+
+        // Assert
+        VerifyModel(model, action);
+        this.VerifyState(variableName, expectedValue);
+    }
+
+    private SetVariable CreateModel(string displayName, string variablePath, ValueExpression.Builder valueExpression)
+    {
+        SetVariable.Builder actionBuilder =
+            new()
+            {
+                Id = this.CreateActionId(),
+                DisplayName = this.FormatDisplayName(displayName),
+                Variable = InitializablePropertyPath.Create(variablePath),
+                Value = valueExpression,
+            };
+
+        return AssignParent<SetVariable>(actionBuilder);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/ObjectModel/WorkflowActionExecutorTest.cs

@@ -0,0 +1,78 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Agents.AI.Workflows.Declarative.Extensions;
+using Microsoft.Agents.AI.Workflows.Declarative.Interpreter;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.Agents.AI.Workflows.Reflection;
+using Microsoft.Bot.ObjectModel;
+using Microsoft.PowerFx.Types;
+using Xunit.Abstractions;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.ObjectModel;
+
+/// <summary>
+/// Base test class for <see cref="DeclarativeActionExecutor"/> implementations.
+/// </summary>
+public abstract class WorkflowActionExecutorTest(ITestOutputHelper output) : WorkflowTest(output)
+{
+    internal WorkflowFormulaState State { get; } = new(RecalcEngineFactory.Create());
+
+    protected ActionId CreateActionId() => new($"{this.GetType().Name}_{Guid.NewGuid():N}");
+
+    protected string FormatDisplayName(string name) => $"{this.GetType().Name}_{name}";
+
+    internal async Task<WorkflowEvent[]> ExecuteAsync(DeclarativeActionExecutor executor)
+    {
+        TestWorkflowExecutor workflowExecutor = new();
+        WorkflowBuilder workflowBuilder = new(workflowExecutor);
+        workflowBuilder.AddEdge(workflowExecutor, executor);
+        StreamingRun run = await InProcessExecution.StreamAsync(workflowBuilder.Build(), this.State);
+        WorkflowEvent[] events = await run.WatchStreamAsync().ToArrayAsync();
+        Assert.Contains(events, e => e is DeclarativeActionInvokedEvent);
+        Assert.Contains(events, e => e is DeclarativeActionCompletedEvent);
+        return events;
+    }
+
+    internal static void VerifyModel(DialogAction model, DeclarativeActionExecutor action)
+    {
+        Assert.Equal(model.Id, action.Id);
+        Assert.Equal(model, action.Model);
+    }
+
+    protected void VerifyState(string variableName, FormulaValue expectedValue) => this.VerifyState(variableName, WorkflowFormulaState.DefaultScopeName, expectedValue);
+
+    internal void VerifyState(string variableName, string scopeName, FormulaValue expectedValue)
+    {
+        FormulaValue actualValue = this.State.Get(variableName, scopeName);
+        Assert.Equal(expectedValue.Format(), actualValue.Format());
+    }
+
+    internal void VerifyUndefined(string variableName, string? scopeName = null) =>
+        Assert.IsType<BlankValue>(this.State.Get(variableName, scopeName));
+
+    protected static TAction AssignParent<TAction>(DialogAction.Builder actionBuilder) where TAction : DialogAction
+    {
+        OnActivity.Builder activityBuilder =
+            new()
+            {
+                Id = new("root"),
+            };
+
+        activityBuilder.Actions.Add(actionBuilder);
+
+        OnActivity model = activityBuilder.Build();
+
+        return (TAction)model.Actions[0];
+    }
+
+    internal sealed class TestWorkflowExecutor() :
+        ReflectingExecutor<TestWorkflowExecutor>(nameof(TestWorkflowExecutor)),
+        IMessageHandler<WorkflowFormulaState>
+    {
+        public async ValueTask HandleAsync(WorkflowFormulaState message, IWorkflowContext context) =>
+            await context.SendMessageAsync(new ActionExecutorResult(this.Id)).ConfigureAwait(false);
+    }
+}