chore: import upstream snapshot with attribution

2026-07-13 13:39:25 +08:00
commit db620d33df
5151 changed files with 925932 additions and 0 deletions
@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx.Functions;
+using Microsoft.Extensions.AI;
+using Microsoft.PowerFx.Types;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx.Functions;
+
+public sealed class AgentMessageTests
+{
+    [Fact]
+    public void Construct_Function()
+    {
+        AgentMessage function = new();
+        Assert.NotNull(function);
+    }
+
+    [Fact]
+    public void Execute_ReturnsBlank_ForEmptyInput()
+    {
+        // Arrange
+        StringValue sourceValue = FormulaValue.New(string.Empty);
+
+        // Act
+        FormulaValue result = AgentMessage.Execute(sourceValue);
+
+        // Assert
+        Assert.IsType<BlankValue>(result);
+    }
+
+    [Fact]
+    public void Execute_ReturnsExpectedRecord_ForNonEmptyInput()
+    {
+        const string Text = "Hello";
+        FormulaValue sourceValue = FormulaValue.New(Text);
+        StringValue stringValue = Assert.IsType<StringValue>(sourceValue);
+
+        FormulaValue result = AgentMessage.Execute(stringValue);
+
+        RecordValue recordResult = Assert.IsType<RecordValue>(result, exactMatch: false);
+
+        // Discriminator
+        FormulaValue discriminator = recordResult.GetField(TypeSchema.Discriminator);
+        StringValue discriminatorValue = Assert.IsType<StringValue>(discriminator);
+        Assert.Equal(nameof(ChatMessage), discriminatorValue.Value);
+
+        // Role
+        FormulaValue role = recordResult.GetField(TypeSchema.Message.Fields.Role);
+        StringValue roleValue = Assert.IsType<StringValue>(role);
+        Assert.Equal(ChatRole.Assistant.Value, roleValue.Value);
+
+        // Content table
+        FormulaValue content = recordResult.GetField(TypeSchema.Message.Fields.Content);
+        TableValue table = Assert.IsType<TableValue>(content, exactMatch: false);
+
+        List<RecordValue> rows = table.Rows.Select(value => value.Value).ToList();
+        Assert.Single(rows);
+
+        StringValue contentType = Assert.IsType<StringValue>(rows[0].GetField(TypeSchema.MessageContent.Fields.Type));
+        Assert.Equal(TypeSchema.MessageContent.ContentTypes.Text, contentType.Value);
+
+        StringValue contentValue = Assert.IsType<StringValue>(rows[0].GetField(TypeSchema.MessageContent.Fields.Value));
+        Assert.Equal(Text, contentValue.Value);
+    }
+}
@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using Microsoft.Agents.AI.Workflows.Declarative.Extensions;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx.Functions;
+using Microsoft.Extensions.AI;
+using Microsoft.PowerFx.Types;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx.Functions;
+
+public sealed class MessageTextTests
+{
+    [Fact]
+    public void Construct_Function()
+    {
+        MessageText.StringInput function1 = new();
+        Assert.NotNull(function1);
+
+        MessageText.RecordInput function2 = new();
+        Assert.NotNull(function2);
+
+        MessageText.TableInput function3 = new();
+        Assert.NotNull(function3);
+    }
+
+    [Fact]
+    public void Execute_ReturnsEmpty_ForEmptyInput()
+    {
+        // Arrange
+        StringValue sourceValue = FormulaValue.New(string.Empty);
+
+        // Act
+        FormulaValue result = MessageText.StringInput.Execute(sourceValue);
+
+        // Assert
+        StringValue stringResult = Assert.IsType<StringValue>(result);
+        Assert.Empty(stringResult.Value);
+    }
+
+    [Fact]
+    public void Execute_ReturnsText_ForStringInput()
+    {
+        // Arrange
+        StringValue sourceValue = FormulaValue.New("wowsie");
+
+        // Act
+        FormulaValue result = MessageText.StringInput.Execute(sourceValue);
+
+        // Assert
+        StringValue stringResult = Assert.IsType<StringValue>(result);
+        Assert.Equal(sourceValue.Value, stringResult.Value);
+    }
+
+    [Fact]
+    public void Execute_ReturnsText_ForMessageInput()
+    {
+        // Arrange
+        RecordValue sourceValue = new ChatMessage(ChatRole.User, "test message").ToRecord();
+
+        // Act
+        FormulaValue result = MessageText.RecordInput.Execute(sourceValue);
+
+        // Assert
+        StringValue stringResult = Assert.IsType<StringValue>(result);
+        Assert.Equal("test message", stringResult.Value);
+    }
+
+    [Fact]
+    public void Execute_ReturnsEmpty_ForUnknownInput()
+    {
+        // Arrange
+        RecordValue sourceValue = FormulaValue.NewRecordFromFields(new NamedValue("Anything", FormulaValue.New(333)));
+
+        // Act
+        FormulaValue result = MessageText.RecordInput.Execute(sourceValue);
+
+        // Assert
+        StringValue stringResult = Assert.IsType<StringValue>(result);
+        Assert.Empty(stringResult.Value);
+    }
+
+    [Fact]
+    public void Execute_ReturnsText_ForMessagesInput()
+    {
+        // Arrange
+        TableValue sourceValue = new ChatMessage[]
+            {
+                new(ChatRole.User, "test message 1"),
+                new(ChatRole.User, "test message 2"),
+            }.ToTable();
+
+        // Act
+        FormulaValue result = MessageText.TableInput.Execute(sourceValue);
+
+        // Assert
+        StringValue stringResult = Assert.IsType<StringValue>(result);
+        Assert.Equal("test message 1\ntest message 2", stringResult.Value);
+    }
+
+    [Fact]
+    public void Execute_ReturnsEmpty_ForEmptyList()
+    {
+        // Arrange
+        TableValue sourceValue = Array.Empty<ChatMessage>().ToTable();
+
+        // Act
+        FormulaValue result = MessageText.TableInput.Execute(sourceValue);
+
+        // Assert
+        StringValue stringResult = Assert.IsType<StringValue>(result);
+        Assert.Empty(stringResult.Value);
+    }
+}
@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx.Functions;
+using Microsoft.Extensions.AI;
+using Microsoft.PowerFx.Types;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx.Functions;
+
+public class UserMessageTests
+{
+    [Fact]
+    public void Construct_Function()
+    {
+        UserMessage function = new();
+        Assert.NotNull(function);
+    }
+
+    [Fact]
+    public void Execute_ReturnsBlank_ForEmptyInput()
+    {
+        // Arrange
+        StringValue sourceValue = FormulaValue.New(string.Empty);
+
+        // Act
+        FormulaValue result = UserMessage.Execute(sourceValue);
+
+        // Assert
+        Assert.IsType<BlankValue>(result);
+    }
+
+    [Fact]
+    public void Execute_ReturnsExpectedRecord_ForNonEmptyInput()
+    {
+        const string Text = "Hello";
+        FormulaValue sourceValue = FormulaValue.New(Text);
+        StringValue stringValue = Assert.IsType<StringValue>(sourceValue);
+
+        FormulaValue result = UserMessage.Execute(stringValue);
+
+        RecordValue recordResult = Assert.IsType<RecordValue>(result, exactMatch: false);
+
+        // Discriminator
+        FormulaValue discriminator = recordResult.GetField(TypeSchema.Discriminator);
+        StringValue discriminatorValue = Assert.IsType<StringValue>(discriminator);
+        Assert.Equal(nameof(ChatMessage), discriminatorValue.Value);
+
+        // Role
+        FormulaValue role = recordResult.GetField(TypeSchema.Message.Fields.Role);
+        StringValue roleValue = Assert.IsType<StringValue>(role);
+        Assert.Equal(ChatRole.User.Value, roleValue.Value);
+
+        // Content table
+        FormulaValue content = recordResult.GetField(TypeSchema.Message.Fields.Content);
+        TableValue table = Assert.IsType<TableValue>(content, exactMatch: false);
+
+        List<RecordValue> rows = table.Rows.Select(value => value.Value).ToList();
+        Assert.Single(rows);
+
+        StringValue contentType = Assert.IsType<StringValue>(rows[0].GetField(TypeSchema.MessageContent.Fields.Type));
+        Assert.Equal(TypeSchema.MessageContent.ContentTypes.Text, contentType.Value);
+
+        StringValue contentValue = Assert.IsType<StringValue>(rows[0].GetField(TypeSchema.MessageContent.Fields.Value));
+        Assert.Equal(Text, contentValue.Value);
+    }
+}
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.PowerFx;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx;
+
+public class RecalcEngineFactoryTests(ITestOutputHelper output) : WorkflowTest(output)
+{
+    [Fact]
+    public void DefaultNotNull()
+    {
+        // Act
+        RecalcEngine engine = RecalcEngineFactory.Create();
+
+        // Assert
+        Assert.NotNull(engine);
+    }
+
+    [Fact]
+    public void NewInstanceEachTime()
+    {
+        // Act
+        RecalcEngine engine1 = RecalcEngineFactory.Create();
+        RecalcEngine engine2 = RecalcEngineFactory.Create();
+
+        // Assert
+        Assert.NotNull(engine1);
+        Assert.NotNull(engine2);
+        Assert.NotSame(engine1, engine2);
+    }
+
+    [Fact]
+    public void HasSetFunctionEnabled()
+    {
+        // Arrange
+        RecalcEngine engine = RecalcEngineFactory.Create();
+
+        // Act
+        CheckResult result = engine.Check("1+1");
+
+        // Assert
+        Assert.True(result.IsSuccess);
+    }
+
+    [Fact]
+    public void HasCorrectMaximumExpressionLength()
+    {
+        // Arrange
+        RecalcEngine engine = RecalcEngineFactory.Create(2000, 3);
+
+        // Assert
+        Assert.Equal(2000, engine.Config.MaximumExpressionLength);
+        Assert.Equal(3, engine.Config.MaxCallDepth);
+
+        // Act: Create a long expression that is within the limit
+        string goodExpression = string.Concat(GenerateExpression(999));
+        CheckResult goodResult = engine.Check(goodExpression);
+
+        // Assert
+        Assert.True(goodResult.IsSuccess);
+
+        // Act: Create a long expression that exceeds the limit
+        string longExpression = string.Concat(GenerateExpression(1001));
+        CheckResult longResult = engine.Check(longExpression);
+
+        // Assert
+        Assert.False(longResult.IsSuccess);
+
+        static IEnumerable<string> GenerateExpression(int elements)
+        {
+            yield return "1";
+            for (int i = 0; i < elements - 1; i++)
+            {
+                yield return "+1";
+            }
+        }
+    }
+}
@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.PowerFx;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx;
+
+/// <summary>
+/// Base test class for PowerFx engine tests.
+/// </summary>
+public abstract class RecalcEngineTest(ITestOutputHelper output) : WorkflowTest(output)
+{
+    internal WorkflowFormulaState State { get; } = new(RecalcEngineFactory.Create());
+
+    protected RecalcEngine Engine => this.State.Engine;
+}
@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using Microsoft.Agents.AI.Workflows.Declarative.Extensions;
+using Microsoft.Agents.ObjectModel;
+using Microsoft.PowerFx.Types;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx;
+
+public class TemplateExtensionsTests(ITestOutputHelper output) : RecalcEngineTest(output)
+{
+    [Fact]
+    public void FormatTemplateLines()
+    {
+        // Arrange
+        List<TemplateLine> template =
+        [
+            TemplateLine.Parse("Hello"),
+            TemplateLine.Parse(" "),
+            TemplateLine.Parse("World"),
+        ];
+
+        // Act
+        string? result = this.Engine.Format(template);
+
+        // Assert
+        Assert.Equal("Hello World", result);
+    }
+
+    [Fact]
+    public void FormatTemplateLinesEmpty()
+    {
+        // Arrange
+        List<TemplateLine> template = [];
+
+        // Act
+        string? result = this.Engine.Format(template);
+
+        // Assert
+        Assert.Equal(string.Empty, result);
+    }
+
+    [Fact]
+    public void FormatTemplateLine()
+    {
+        // Arrange
+        TemplateLine line = TemplateLine.Parse("Test");
+
+        // Act
+        string? result = this.Engine.Format(line);
+
+        // Assert
+        Assert.Equal("Test", result);
+    }
+
+    [Fact]
+    public void FormatTemplateLineNull()
+    {
+        // Arrange
+        TemplateLine? line = null;
+
+        // Act
+        string? result = this.Engine.Format(line);
+
+        // Assert
+        Assert.Equal(string.Empty, result);
+    }
+
+    [Fact]
+    public void FormatTextSegment()
+    {
+        // Arrange
+        TemplateSegment textSegment = TemplateSegment.FromText("Hello World");
+        TemplateLine line = new([textSegment]);
+
+        // Act
+        string? result = this.Engine.Format(line);
+
+        // Assert
+        Assert.Equal("Hello World", result);
+    }
+
+    [Fact]
+    public void FormatExpressionSegment()
+    {
+        // Arrange
+        ExpressionSegment expressionSegment = new(ValueExpression.Expression("1 + 1"));
+        TemplateLine line = new([expressionSegment]);
+
+        // Act
+        string? result = this.Engine.Format(line);
+
+        // Assert
+        Assert.Equal("2", result);
+    }
+
+    [Fact]
+    public void FormatVariableSegment()
+    {
+        // Arrange
+        this.State.Set("Source", FormulaValue.New("Hello World"));
+        this.State.Bind();
+
+        ExpressionSegment expressionSegment = new(ValueExpression.Variable(PropertyPath.TopicVariable("Source")));
+        TemplateLine line = new([expressionSegment]);
+
+        // Act
+        string? result = this.Engine.Format(line);
+
+        // Assert
+        Assert.Equal("Hello World", result);
+    }
+
+    [Fact]
+    public void FormatExpressionSegmentUndefined()
+    {
+        // Arrange
+        ExpressionSegment expressionSegment = new();
+        TemplateLine line = new([expressionSegment]);
+
+        // Act & Assert
+        Assert.Throws<DeclarativeModelException>(() => this.Engine.Format(line));
+    }
+
+    [Fact]
+    public void FormatMultipleSegments()
+    {
+        // Arrange
+        TemplateSegment textSegment = TemplateSegment.FromText("Hello ");
+        ExpressionSegment expressionSegment = new(ValueExpression.Expression(@"""World"""));
+        TemplateLine line = new([textSegment, expressionSegment]);
+
+        // Act
+        string? result = this.Engine.Format(line);
+
+        // Assert
+        Assert.Equal("Hello World", result);
+    }
+}
@@ -0,0 +1,551 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Immutable;
+using Microsoft.Agents.AI.Workflows.Declarative.Extensions;
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.Agents.ObjectModel;
+using Microsoft.Agents.ObjectModel.Abstractions;
+using Microsoft.Agents.ObjectModel.Exceptions;
+using Microsoft.PowerFx.Types;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx;
+
+public class WorkflowExpressionEngineTests : RecalcEngineTest
+{
+    private static class Variables
+    {
+        public const string GlobalValue = nameof(GlobalValue);
+        public const string BoolValue = nameof(BoolValue);
+        public const string StringValue = nameof(StringValue);
+        public const string IntValue = nameof(IntValue);
+        public const string NumberValue = nameof(NumberValue);
+        public const string EnumValue = nameof(EnumValue);
+        public const string ObjectValue = nameof(ObjectValue);
+        public const string ArrayValue = nameof(ArrayValue);
+        public const string BlankValue = nameof(BlankValue);
+    }
+
+    public static readonly RecordValue ObjectData = FormulaValue.NewRecordFromFields(new NamedValue(nameof(EnvironmentVariableReference.SchemaName), FormulaValue.New("test")));
+    public static readonly TableValue TableData = FormulaValue.NewSingleColumnTable(FormulaValue.New("a"), FormulaValue.New("b"));
+
+    public WorkflowExpressionEngineTests(ITestOutputHelper output)
+        : base(output)
+    {
+        this.State.Set(Variables.GlobalValue, FormulaValue.New(255), VariableScopeNames.Global);
+        this.State.Set(Variables.BoolValue, FormulaValue.New(true));
+        this.State.Set(Variables.StringValue, FormulaValue.New("Hello World"));
+        this.State.Set(Variables.IntValue, FormulaValue.New(long.MaxValue));
+        this.State.Set(Variables.NumberValue, FormulaValue.New(33.3));
+        this.State.Set(Variables.EnumValue, FormulaValue.New(nameof(VariablesToClear.ConversationScopedVariables)));
+        this.State.Set(Variables.ObjectValue, ObjectData);
+        this.State.Set(Variables.ArrayValue, TableData);
+        this.State.Set(Variables.BlankValue, FormulaValue.NewBlank());
+        this.State.Bind();
+    }
+
+    #region BoolExpression Tests
+
+    [Fact]
+    public void BoolExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<ArgumentNullException>((BoolExpression)null!);
+
+    [Fact]
+    public void BoolExpressionGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<InvalidExpressionOutputTypeException>(BoolExpression.Variable(PropertyPath.TopicVariable(Variables.StringValue)));
+
+    [Fact]
+    public void BoolExpressionGetValueForLiteral() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            BoolExpression.Literal(true),
+            expectedValue: true);
+
+    [Fact]
+    public void BoolExpressionGetValueForBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            BoolExpression.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: false);
+
+    [Fact]
+    public void BoolExpressionGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            BoolExpression.Variable(PropertyPath.TopicVariable(Variables.BoolValue)),
+            expectedValue: true);
+    }
+
+    [Fact]
+    public void BoolExpressionGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            BoolExpression.Expression("true || false"),
+            expectedValue: true);
+
+    #endregion
+
+    #region StringExpression Tests
+
+    [Fact]
+    public void StringExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<ArgumentNullException>((StringExpression)null!);
+
+    [Fact]
+    public void StringExpressionGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<InvalidExpressionOutputTypeException>(StringExpression.Variable(PropertyPath.TopicVariable(Variables.BoolValue)));
+
+    [Fact]
+    public void StringExpressionGetValueForStringExpressionBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            StringExpression.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: string.Empty);
+
+    [Fact]
+    public void StringExpressionGetValueForLiteral() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            StringExpression.Literal("test"),
+            expectedValue: "test");
+
+    [Fact]
+    public void StringExpressionGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            StringExpression.Variable(PropertyPath.TopicVariable(Variables.StringValue)),
+            expectedValue: "Hello World");
+    }
+
+    [Fact]
+    public void StringExpressionGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            StringExpression.Expression(@"""A"" & ""B"""),
+            expectedValue: "AB");
+
+    [Fact]
+    public void StringExpressionGetValueForRecord()
+    {
+        // Arrange
+        RecordValue state = FormulaValue.NewRecordFromFields([new NamedValue("test", FormulaValue.New("value"))]);
+        this.State.Set("TestRecord", state, VariableScopeNames.Global);
+        this.State.Bind();
+
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            StringExpression.Variable(PropertyPath.Create("Global.TestRecord")),
+            expectedValue:
+                """
+                {
+                  "test": "value"
+                }
+                """.Replace("\n", Environment.NewLine));
+    }
+
+    #endregion
+
+    #region IntExpression Tests
+
+    [Fact]
+    public void IntExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<ArgumentNullException>((IntExpression)null!);
+
+    [Fact]
+    public void IntExpressionGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<InvalidExpressionOutputTypeException>(IntExpression.Variable(PropertyPath.TopicVariable(Variables.StringValue)));
+
+    [Fact]
+    public void IntExpressionGetValueForIntExpressionBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            IntExpression.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: 0);
+
+    [Fact]
+    public void IntExpressionGetValueForLiteral() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            IntExpression.Literal(7),
+            expectedValue: 7);
+
+    [Fact]
+    public void IntExpressionGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            IntExpression.Variable(PropertyPath.TopicVariable(Variables.IntValue)),
+            expectedValue: long.MaxValue);
+    }
+
+    [Fact]
+    public void IntExpressionGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            IntExpression.Expression("1 + 6"),
+            expectedValue: 7);
+
+    #endregion
+
+    #region NumberExpression Tests
+
+    [Fact]
+    public void NumberExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<ArgumentNullException>((NumberExpression)null!);
+
+    [Fact]
+    public void NumberExpressionGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<InvalidExpressionOutputTypeException>(NumberExpression.Variable(PropertyPath.TopicVariable(Variables.StringValue)));
+
+    [Fact]
+    public void NumberExpressionGetValueForBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            NumberExpression.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: 0);
+
+    [Fact]
+    public void NumberExpressionGetValueForLiteral() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            NumberExpression.Literal(3.14),
+            expectedValue: 3.14);
+
+    [Fact]
+    public void NumberExpressionGetValueForVariable() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            NumberExpression.Variable(PropertyPath.TopicVariable(Variables.NumberValue)),
+            expectedValue: 33.3);
+
+    [Fact]
+    public void NumberExpressionGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            NumberExpression.Expression("31.1 + 2.2"),
+            expectedValue: 33.3);
+
+    #endregion
+
+    #region DataValueExpression Tests
+
+    [Fact]
+    public void DataValueExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<ArgumentNullException>((ValueExpression)null!);
+
+    [Fact]
+    public void DataValueExpressionGetValueForDataValueExpressionBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ValueExpression.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: DataValue.Blank());
+
+    [Fact]
+    public void DataValueExpressionGetValueForLiteral() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ValueExpression.Literal(DataValue.Create("test")),
+            expectedValue: DataValue.Create("test"));
+
+    [Fact]
+    public void DataValueExpressionGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ValueExpression.Variable(PropertyPath.TopicVariable(Variables.StringValue)),
+            expectedValue: DataValue.Create("Hello World"));
+    }
+
+    [Fact]
+    public void DataValueExpressionGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ValueExpression.Expression(@"""A"" & ""B"""),
+            expectedValue: DataValue.Create("AB"));
+
+    #endregion
+
+    #region EnumExpression Tests
+
+    [Fact]
+    public void EnumExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<VariablesToClearWrapper, ArgumentNullException>((EnumExpression<VariablesToClearWrapper>)null!);
+
+    [Fact]
+    public void EnumExpressionGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<VariablesToClearWrapper, InvalidExpressionOutputTypeException>(EnumExpression<VariablesToClearWrapper>.Variable(PropertyPath.TopicVariable(Variables.BoolValue)));
+
+    [Fact]
+    public void EnumExpressionGetValueForLiteral() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            EnumExpression<VariablesToClearWrapper>.Literal(VariablesToClearWrapper.Get(VariablesToClear.ConversationScopedVariables)),
+            expectedValue: VariablesToClear.ConversationScopedVariables);
+
+    [Fact]
+    public void EnumExpressionGetValueForBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            EnumExpression<VariablesToClearWrapper>.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: VariablesToClear.ConversationScopedVariables);
+
+    [Fact]
+    public void EnumExpressionGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            EnumExpression<VariablesToClearWrapper>.Variable(PropertyPath.TopicVariable(Variables.EnumValue)),
+            expectedValue: VariablesToClear.ConversationScopedVariables);
+    }
+
+    [Fact]
+    public void EnumExpressionGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            EnumExpression<VariablesToClearWrapper>.Expression(@"""ConversationScoped"" & ""Variables"""),
+            expectedValue: VariablesToClear.ConversationScopedVariables);
+
+    #endregion
+
+    #region ObjectExpression Tests
+
+    [Fact]
+    public void ObjectExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<RecordDataValue, ArgumentNullException>((ObjectExpression<RecordDataValue>)null!);
+
+    [Fact]
+    public void ObjectExpressionGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<RecordDataValue, InvalidExpressionOutputTypeException>(ObjectExpression<RecordDataValue>.Variable(PropertyPath.TopicVariable(Variables.BoolValue)));
+
+    [Fact]
+    public void ObjectExpressionGetValueForLiteral()
+    {
+        // Arrange, Act & Assert
+        RecordDataValue.Builder recordBuilder = new();
+        recordBuilder.Properties.Add(nameof(EnvironmentVariableReference.SchemaName), new StringDataValue("test"));
+        RecordDataValue objectRecord = recordBuilder.Build();
+        _ = new EnvironmentVariableReference.Builder() { SchemaName = "test" }.Build();
+        this.EvaluateExpression(
+            ObjectExpression<RecordDataValue>.Literal(objectRecord),
+            expectedValue: objectRecord);
+    }
+
+    [Fact]
+    public void ObjectExpressionGetValueForBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ObjectExpression<RecordDataValue>.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: null);
+
+    [Fact]
+    public void ObjectExpressionGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ObjectExpression<RecordDataValue>.Variable(PropertyPath.TopicVariable(Variables.ObjectValue)),
+            expectedValue: ObjectData.ToRecord());
+    }
+
+    #endregion
+
+    #region ArrayExpression Tests
+
+    [Fact]
+    public void ArrayExpressionGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<string, ArgumentNullException>((ArrayExpression<string>)null!);
+
+    [Fact]
+    public void ArrayExpressionGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<string, InvalidExpressionOutputTypeException>(ArrayExpression<string>.Variable(PropertyPath.TopicVariable(Variables.BoolValue)));
+
+    [Fact]
+    public void ArrayExpressionGetValueForLiteral()
+    {
+        // Arrange, Act & Assert
+        string[] input = ["a", "b"];
+        this.EvaluateExpression(
+            ArrayExpression<string>.Literal(input.ToImmutableArray()),
+            expectedValue: input);
+    }
+
+    [Fact]
+    public void ArrayExpressionGetValueForBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ArrayExpression<string>.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: []);
+
+    [Fact]
+    public void ArrayExpressionGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ArrayExpression<string>.Variable(PropertyPath.TopicVariable(Variables.ArrayValue)),
+            expectedValue: ["a", "b"]);
+    }
+
+    [Fact]
+    public void ArrayExpressionGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ArrayExpression<string>.Expression(@"[""a"", ""b""]"),
+            expectedValue: ["a", "b"]);
+
+    #endregion
+
+    #region ArrayExpressionOnly Tests
+
+    [Fact]
+    public void ArrayExpressionOnlyGetValueForNull() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<string, ArgumentNullException>((ArrayExpressionOnly<string>)null!);
+
+    [Fact]
+    public void ArrayExpressionOnlyGetValueForInvalid() =>
+        // Arrange, Act & Assert
+        this.EvaluateInvalidExpression<string, InvalidExpressionOutputTypeException>(ArrayExpressionOnly<string>.Variable(PropertyPath.TopicVariable(Variables.BoolValue)));
+
+    [Fact]
+    public void ArrayExpressionOnlyGetValueForBlank() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ArrayExpressionOnly<string>.Variable(PropertyPath.TopicVariable(Variables.BlankValue)),
+            expectedValue: []);
+
+    [Fact]
+    public void ArrayExpressionOnlyGetValueForVariable()
+    {
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ArrayExpressionOnly<string>.Variable(PropertyPath.TopicVariable(Variables.ArrayValue)),
+            expectedValue: ["a", "b"]);
+    }
+
+    [Fact]
+    public void ArrayExpressionOnlyGetValueForFormula() =>
+        // Arrange, Act & Assert
+        this.EvaluateExpression(
+            ArrayExpressionOnly<string>.Expression(@"[""a"", ""b""]"),
+            expectedValue: ["a", "b"]);
+
+    #endregion
+
+    private EvaluationResult<bool> EvaluateExpression(BoolExpression expression, bool expectedValue, SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+        => this.EvaluateExpression((evaluator) => evaluator.GetValue(expression), expectedValue, expectedSensitivity);
+
+    private void EvaluateInvalidExpression<TException>(BoolExpression expression)
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private EvaluationResult<string> EvaluateExpression(StringExpression expression, string expectedValue, SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+        => this.EvaluateExpression((evaluator) => evaluator.GetValue(expression), expectedValue, expectedSensitivity);
+
+    private void EvaluateInvalidExpression<TException>(StringExpression expression)
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private EvaluationResult<long> EvaluateExpression(IntExpression expression, long expectedValue, SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+        => this.EvaluateExpression((evaluator) => evaluator.GetValue(expression), expectedValue, expectedSensitivity);
+
+    private void EvaluateInvalidExpression<TException>(IntExpression expression)
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private EvaluationResult<double> EvaluateExpression(NumberExpression expression, double expectedValue, SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+        => this.EvaluateExpression((evaluator) => evaluator.GetValue(expression), expectedValue, expectedSensitivity);
+
+    private void EvaluateInvalidExpression<TException>(NumberExpression expression)
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private EvaluationResult<DataValue> EvaluateExpression(ValueExpression expression, DataValue expectedValue, SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+        => this.EvaluateExpression((evaluator) => evaluator.GetValue(expression), expectedValue, expectedSensitivity);
+
+    private void EvaluateInvalidExpression<TException>(ValueExpression expression)
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private EvaluationResult<TEnum> EvaluateExpression<TEnum>(EnumExpression<TEnum> expression, TEnum expectedValue, SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+        where TEnum : EnumWrapper
+        => this.EvaluateExpression((evaluator) => evaluator.GetValue(expression), expectedValue, expectedSensitivity);
+
+    private void EvaluateInvalidExpression<TEnum, TException>(EnumExpression<TEnum> expression)
+        where TEnum : EnumWrapper
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private EvaluationResult<TValue?> EvaluateExpression<TValue>(ObjectExpression<TValue> expression, TValue? expectedValue, SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+        where TValue : BotElement
+        => this.EvaluateExpression((evaluator) => evaluator.GetValue(expression), expectedValue, expectedSensitivity);
+
+    private void EvaluateInvalidExpression<TValue, TException>(ObjectExpression<TValue> expression)
+        where TValue : BotElement
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private ImmutableArray<TValue> EvaluateExpression<TValue>(ArrayExpression<TValue> expression, TValue[] expectedValue)
+        => this.EvaluateArrayExpression((evaluator) => evaluator.GetValue(expression), expectedValue);
+
+    private void EvaluateInvalidExpression<TValue, TException>(ArrayExpression<TValue> expression)
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private ImmutableArray<TValue> EvaluateExpression<TValue>(ArrayExpressionOnly<TValue> expression, TValue[] expectedValue)
+        => this.EvaluateArrayExpression((evaluator) => evaluator.GetValue(expression), expectedValue);
+
+    private void EvaluateInvalidExpression<TValue, TException>(ArrayExpressionOnly<TValue> expression)
+        where TException : Exception
+        => this.EvaluateInvalidExpression<TException>((evaluator) => evaluator.GetValue(expression));
+
+    private EvaluationResult<TValue> EvaluateExpression<TValue>(
+        Func<WorkflowExpressionEngine, EvaluationResult<TValue>> evaluator,
+        TValue? expectedValue,
+        SensitivityLevel expectedSensitivity = SensitivityLevel.None)
+    {
+        // Act
+        EvaluationResult<TValue> result = evaluator.Invoke(this.State.Evaluator);
+
+        // Assert
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedSensitivity, result.Sensitivity);
+
+        return result;
+    }
+
+    private ImmutableArray<TValue> EvaluateArrayExpression<TValue>(
+        Func<WorkflowExpressionEngine, ImmutableArray<TValue>> evaluator,
+        TValue[] expectedValue)
+    {
+        // Act
+        ImmutableArray<TValue> result = evaluator.Invoke(this.State.Evaluator);
+
+        // Assert
+        Assert.Equal(expectedValue.Length, result.Length);
+        Assert.Equivalent(expectedValue, result);
+
+        return result;
+    }
+
+    private void EvaluateInvalidExpression<TException>(Action<WorkflowExpressionEngine> evaluator) where TException : Exception
+    {
+        // Act & Assert
+        Assert.Throws<TException>(() => evaluator.Invoke(this.State.Evaluator));
+    }
+}
@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.Workflows.Declarative.PowerFx;
+using Microsoft.Agents.ObjectModel;
+using Microsoft.PowerFx.Types;
+
+namespace Microsoft.Agents.AI.Workflows.Declarative.UnitTests.PowerFx;
+
+public class WorkflowFormulaStateTests
+{
+    internal WorkflowFormulaState State { get; } = new(RecalcEngineFactory.Create());
+
+    [Fact]
+    public void GetWithImplicitScope()
+    {
+        // Arrange
+        FormulaValue testValue = FormulaValue.New("test");
+        this.State.Set("key1", testValue);
+
+        // Act
+        FormulaValue result = this.State.Get("key1");
+
+        // Assert
+        Assert.Equal(testValue, result);
+    }
+
+    [Fact]
+    public void GetWithSpecifiedScope()
+    {
+        // Arrange
+        FormulaValue testValue = FormulaValue.New("test");
+        this.State.Set("key1", testValue, VariableScopeNames.Global);
+
+        // Act
+        FormulaValue result = this.State.Get("key1", VariableScopeNames.Global);
+
+        // Assert
+        Assert.Equal(testValue, result);
+    }
+
+    [Fact]
+    public void SetDefaultScope()
+    {
+        // Arrange
+        FormulaValue testValue = FormulaValue.New("test");
+
+        // Act
+        this.State.Set("key1", testValue);
+
+        // Assert
+        FormulaValue result = this.State.Get("key1");
+        Assert.Equal(testValue, result);
+    }
+
+    [Fact]
+    public void SetSpecifiedScope()
+    {
+        // Arrange
+        FormulaValue testValue = FormulaValue.New("test");
+
+        // Act
+        this.State.Set("key1", testValue, VariableScopeNames.System);
+
+        // Assert
+        FormulaValue result = this.State.Get("key1", VariableScopeNames.System);
+        Assert.Equal(testValue, result);
+    }
+
+    [Fact]
+    public void SetOverwritesExistingValue()
+    {
+        // Arrange
+        FormulaValue initialValue = FormulaValue.New("initial");
+        FormulaValue newValue = FormulaValue.New("new");
+
+        // Act
+        this.State.Set("key1", initialValue);
+        this.State.Set("key1", newValue);
+
+        // Assert
+        FormulaValue result = this.State.Get("key1");
+        Assert.Equal(newValue, result);
+    }
+}