test

dotnet/tests/Microsoft.Agents.AI.DurableTask.UnitTests/AgentSessionIdTests.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.DurableTask.Entities;
+
+namespace Microsoft.Agents.AI.DurableTask.UnitTests;
+
+public sealed class AgentSessionIdTests
+{
+    [Fact]
+    public void ParseValidSessionId()
+    {
+        const string Name = "test-agent";
+        const string Key = "12345";
+        string sessionIdString = $"@dafx-{Name}@{Key}";
+        AgentSessionId sessionId = AgentSessionId.Parse(sessionIdString);
+
+        Assert.Equal(Name, sessionId.Name);
+        Assert.Equal(Key, sessionId.Key);
+    }
+
+    [Fact]
+    public void ParseInvalidSessionId()
+    {
+        const string InvalidSessionIdString = "@test-agent@12345"; // Missing "dafx-" prefix
+        Assert.Throws<ArgumentException>(() => AgentSessionId.Parse(InvalidSessionIdString));
+    }
+
+    [Fact]
+    public void FromEntityId()
+    {
+        const string Name = "test-agent";
+        const string Key = "12345";
+
+        EntityInstanceId entityId = new($"dafx-{Name}", Key);
+        AgentSessionId sessionId = (AgentSessionId)entityId;
+
+        Assert.Equal(Name, sessionId.Name);
+        Assert.Equal(Key, sessionId.Key);
+    }
+
+    [Fact]
+    public void FromInvalidEntityId()
+    {
+        const string Name = "test-agent";
+        const string Key = "12345";
+
+        EntityInstanceId entityId = new(Name, Key); // Missing "dafx-" prefix
+
+        Assert.Throws<ArgumentException>(() =>
+        {
+            // This assignment should throw an exception because
+            // the entity ID is not a valid agent session ID.
+            AgentSessionId sessionId = entityId;
+        });
+    }
+}

dotnet/tests/Microsoft.Agents.AI.DurableTask.UnitTests/DurableAgentThreadTests.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+
+namespace Microsoft.Agents.AI.DurableTask.UnitTests;
+
+public sealed class DurableAgentThreadTests
+{
+    [Fact]
+    public void BuiltInSerialization()
+    {
+        AgentSessionId sessionId = AgentSessionId.WithRandomKey("test-agent");
+        AgentThread thread = new DurableAgentThread(sessionId);
+
+        JsonElement serializedThread = thread.Serialize();
+
+        // Expected format: "{\"sessionId\":\"@dafx-test-agent@<random-key>\"}"
+        string expectedSerializedThread = $"{{\"sessionId\":\"@dafx-{sessionId.Name}@{sessionId.Key}\"}}";
+        Assert.Equal(expectedSerializedThread, serializedThread.ToString());
+
+        DurableAgentThread deserializedThread = DurableAgentThread.Deserialize(serializedThread);
+        Assert.Equal(sessionId, deserializedThread.SessionId);
+    }
+
+    [Fact]
+    public void STJSerialization()
+    {
+        AgentSessionId sessionId = AgentSessionId.WithRandomKey("test-agent");
+        AgentThread thread = new DurableAgentThread(sessionId);
+
+        // Need to specify the type explicitly because STJ, unlike other serializers,
+        // does serialization based on the static type of the object, not the runtime type.
+        string serializedThread = JsonSerializer.Serialize(thread, typeof(DurableAgentThread));
+
+        // Expected format: "{\"sessionId\":\"@dafx-test-agent@<random-key>\"}"
+        string expectedSerializedThread = $"{{\"sessionId\":\"@dafx-{sessionId.Name}@{sessionId.Key}\"}}";
+        Assert.Equal(expectedSerializedThread, serializedThread);
+
+        DurableAgentThread? deserializedThread = JsonSerializer.Deserialize<DurableAgentThread>(serializedThread);
+        Assert.NotNull(deserializedThread);
+        Assert.Equal(sessionId, deserializedThread.SessionId);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.DurableTask.UnitTests/Microsoft.Agents.AI.DurableTask.UnitTests.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(TargetFrameworksCore)</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UserSecretsId>b7762d10-e29b-4bb1-8b74-b6d69a667dd4</UserSecretsId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Microsoft.Agents.AI.DurableTask\Microsoft.Agents.AI.DurableTask.csproj" />
+  </ItemGroup>
+
+</Project>

dotnet/tests/Microsoft.Agents.AI.DurableTask.UnitTests/State/DurableAgentStateContentTests.cs

@@ -0,0 +1,324 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using System.Text.Json.Serialization.Metadata;
+using Microsoft.Agents.AI.DurableTask.State;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.DurableTask.Tests.Unit.State;
+
+public sealed class DurableAgentStateContentTests
+{
+    private static readonly JsonTypeInfo s_stateContentTypeInfo =
+        DurableAgentStateJsonContext.Default.GetTypeInfo(typeof(DurableAgentStateContent))!;
+
+    [Fact]
+    public void ErrorContentSerializationDeserialization()
+    {
+        // Arrange
+        ErrorContent errorContent = new("message")
+        {
+            Details = "details",
+            ErrorCode = "code"
+        };
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(errorContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        ErrorContent convertedErrorContent = Assert.IsType<ErrorContent>(convertedContent);
+
+        Assert.Equal(errorContent.Message, convertedErrorContent.Message);
+        Assert.Equal(errorContent.Details, convertedErrorContent.Details);
+        Assert.Equal(errorContent.ErrorCode, convertedErrorContent.ErrorCode);
+    }
+
+    [Fact]
+    public void TextContentSerializationDeserialization()
+    {
+        // Arrange
+        TextContent textContent = new("Hello, world!");
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(textContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        TextContent convertedTextContent = Assert.IsType<TextContent>(convertedContent);
+
+        Assert.Equal(textContent.Text, convertedTextContent.Text);
+    }
+
+    [Fact]
+    public void FunctionCallContentSerializationDeserialization()
+    {
+        // Arrange
+        FunctionCallContent functionCallContent = new(
+            "call-123",
+            "MyFunction",
+            new Dictionary<string, object?>
+            {
+                { "param1", 42 },
+                { "param2", "value" }
+            });
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(functionCallContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        FunctionCallContent convertedFunctionCallContent = Assert.IsType<FunctionCallContent>(convertedContent);
+
+        Assert.Equal(functionCallContent.CallId, convertedFunctionCallContent.CallId);
+        Assert.Equal(functionCallContent.Name, convertedFunctionCallContent.Name);
+
+        Assert.NotNull(functionCallContent.Arguments);
+        Assert.NotNull(convertedFunctionCallContent.Arguments);
+        Assert.Equal(functionCallContent.Arguments.Keys.Order(), convertedFunctionCallContent.Arguments.Keys.Order());
+
+        // NOTE: Deserialized dictionaries will have JSON element values rather than the original native types,
+        // so we only check the keys here.
+        foreach (string key in functionCallContent.Arguments.Keys)
+        {
+            Assert.Equal(
+                JsonSerializer.Serialize(functionCallContent.Arguments[key]),
+                JsonSerializer.Serialize(convertedFunctionCallContent.Arguments[key]));
+        }
+    }
+
+    [Fact]
+    public void FunctionResultContentSerializationDeserialization()
+    {
+        // Arrange
+        FunctionResultContent functionResultContent = new("call-123", "return value");
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(functionResultContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        FunctionResultContent convertedFunctionResultContent = Assert.IsType<FunctionResultContent>(convertedContent);
+
+        Assert.Equal(functionResultContent.CallId, convertedFunctionResultContent.CallId);
+        // NOTE: We serialize both results to JSON for comparison since deserialized objects will be
+        // JSON elements rather than the original native types.
+        Assert.Equal(
+            JsonSerializer.Serialize(functionResultContent.Result),
+            JsonSerializer.Serialize(convertedFunctionResultContent.Result));
+    }
+
+    [Theory]
+    [InlineData("data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==", null)] // Valid data URI containing media type; pass null for separate mediaType parameter.
+    [InlineData("data:;base64,SGVsbG8sIFdvcmxkIQ==", "text/plain")] // Valid data URI without media type; pass media
+    public void DataContentSerializationDeserialization(string dataUri, string? mediaType)
+    {
+        // Arrange
+        DataContent dataContent = new(dataUri, mediaType);
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(dataContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        DataContent convertedDataContent = Assert.IsType<DataContent>(convertedContent);
+
+        Assert.Equal(dataContent.Uri, convertedDataContent.Uri);
+        Assert.Equal(dataContent.MediaType, convertedDataContent.MediaType);
+    }
+
+    [Fact]
+    public void HostedFileContentSerializationDeserialization()
+    {
+        // Arrange
+        HostedFileContent hostedFileContent = new("file-123");
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(hostedFileContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        HostedFileContent convertedHostedFileContent = Assert.IsType<HostedFileContent>(convertedContent);
+
+        Assert.Equal(hostedFileContent.FileId, convertedHostedFileContent.FileId);
+    }
+
+    [Fact]
+    public void HostedVectorStoreContentSerializationDeserialization()
+    {
+        // Arrange
+        HostedVectorStoreContent hostedVectorStoreContent = new("vs-123");
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(hostedVectorStoreContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        HostedVectorStoreContent convertedHostedVectorStoreContent = Assert.IsType<HostedVectorStoreContent>(convertedContent);
+
+        Assert.Equal(hostedVectorStoreContent.VectorStoreId, convertedHostedVectorStoreContent.VectorStoreId);
+    }
+
+    [Fact]
+    public void TextReasoningContentSerializationDeserialization()
+    {
+        // Arrange
+        TextReasoningContent textReasoningContent = new("Reasoning chain...");
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(textReasoningContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        TextReasoningContent convertedTextReasoningContent = Assert.IsType<TextReasoningContent>(convertedContent);
+
+        Assert.Equal(textReasoningContent.Text, convertedTextReasoningContent.Text);
+    }
+
+    [Fact]
+    public void UriContentSerializationDeserialization()
+    {
+        // Arrange
+        UriContent uriContent = new(new Uri("https://example.com"), "text/html");
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(uriContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        UriContent convertedUriContent = Assert.IsType<UriContent>(convertedContent);
+
+        Assert.Equal(uriContent.Uri, convertedUriContent.Uri);
+        Assert.Equal(uriContent.MediaType, convertedUriContent.MediaType);
+    }
+
+    [Fact]
+    public void UsageContentSerializationDeserialization()
+    {
+        // Arrange
+        UsageDetails usageDetails = new()
+        {
+            InputTokenCount = 10,
+            OutputTokenCount = 5,
+            TotalTokenCount = 15
+        };
+
+        UsageContent usageContent = new(usageDetails);
+
+        DurableAgentStateContent durableContent = DurableAgentStateContent.FromAIContent(usageContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        UsageContent convertedUsageContent = Assert.IsType<UsageContent>(convertedContent);
+
+        Assert.NotNull(convertedUsageContent.Details);
+        Assert.Equal(usageDetails.InputTokenCount, convertedUsageContent.Details.InputTokenCount);
+        Assert.Equal(usageDetails.OutputTokenCount, convertedUsageContent.Details.OutputTokenCount);
+        Assert.Equal(usageDetails.TotalTokenCount, convertedUsageContent.Details.TotalTokenCount);
+    }
+
+    [Fact]
+    public void UnknownContentSerializationDeserialization()
+    {
+        // Arrange
+        TextContent originalContent = new("Some unknown content");
+
+        DurableAgentStateContent durableContent = DurableAgentStateUnknownContent.FromUnknownContent(originalContent);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(durableContent, s_stateContentTypeInfo);
+
+        DurableAgentStateContent? convertedJsonContent =
+            (DurableAgentStateContent?)JsonSerializer.Deserialize(jsonContent, s_stateContentTypeInfo);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        AIContent convertedContent = convertedJsonContent.ToAIContent();
+
+        TextContent convertedTextContent = Assert.IsType<TextContent>(convertedContent);
+
+        Assert.Equal(originalContent.Text, convertedTextContent.Text);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.DurableTask.UnitTests/State/DurableAgentStateMessageTests.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using Microsoft.Agents.AI.DurableTask.State;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.DurableTask.Tests.Unit.State;
+
+public sealed class DurableAgentStateMessageTests
+{
+    [Fact]
+    public void MessageSerializationDeserialization()
+    {
+        // Arrange
+        TextContent textContent = new("Hello, world!");
+        ChatMessage message = new(ChatRole.User, [textContent])
+        {
+            AuthorName = "User123",
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+
+        DurableAgentStateMessage durableMessage = DurableAgentStateMessage.FromChatMessage(message);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(
+            durableMessage,
+            DurableAgentStateJsonContext.Default.GetTypeInfo(typeof(DurableAgentStateMessage))!);
+
+        DurableAgentStateMessage? convertedJsonContent = (DurableAgentStateMessage?)JsonSerializer.Deserialize(
+            jsonContent,
+            DurableAgentStateJsonContext.Default.GetTypeInfo(typeof(DurableAgentStateMessage))!);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+
+        ChatMessage convertedMessage = convertedJsonContent.ToChatMessage();
+
+        Assert.Equal(message.AuthorName, convertedMessage.AuthorName);
+        Assert.Equal(message.CreatedAt, convertedMessage.CreatedAt);
+        Assert.Equal(message.Role, convertedMessage.Role);
+
+        AIContent convertedContent = Assert.Single(convertedMessage.Contents);
+        TextContent convertedTextContent = Assert.IsType<TextContent>(convertedContent);
+
+        Assert.Equal(textContent.Text, convertedTextContent.Text);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.DurableTask.UnitTests/State/DurableAgentStateRequestTests.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using Microsoft.Agents.AI.DurableTask.State;
+
+namespace Microsoft.Agents.AI.DurableTask.Tests.Unit.State;
+
+public sealed class DurableAgentStateRequestTests
+{
+    [Fact]
+    public void RequestSerializationDeserialization()
+    {
+        // Arrange
+        RunRequest originalRequest = new("Hello, world!")
+        {
+            OrchestrationId = "orch-456"
+        };
+        DurableAgentStateRequest originalDurableRequest = DurableAgentStateRequest.FromRunRequest(originalRequest);
+
+        // Act
+        string jsonContent = JsonSerializer.Serialize(
+            originalDurableRequest,
+            DurableAgentStateJsonContext.Default.GetTypeInfo(typeof(DurableAgentStateRequest))!);
+
+        DurableAgentStateRequest? convertedJsonContent = (DurableAgentStateRequest?)JsonSerializer.Deserialize(
+            jsonContent,
+            DurableAgentStateJsonContext.Default.GetTypeInfo(typeof(DurableAgentStateRequest))!);
+
+        // Assert
+        Assert.NotNull(convertedJsonContent);
+        Assert.Equal(originalRequest.CorrelationId, convertedJsonContent.CorrelationId);
+        Assert.Equal(originalRequest.OrchestrationId, convertedJsonContent.OrchestrationId);
+    }
+}

dotnet/tests/Microsoft.Agents.AI.DurableTask.UnitTests/State/DurableAgentStateTests.cs

@@ -0,0 +1,170 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using Microsoft.Agents.AI.DurableTask.State;
+
+namespace Microsoft.Agents.AI.DurableTask.Tests.Unit.State;
+
+public sealed class DurableAgentStateTests
+{
+    [Fact]
+    public void InvalidVersion()
+    {
+        // Arrange
+        const string JsonText = """
+            {
+                "schemaVersion": "hello"
+            }
+            """;
+
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(
+            () => JsonSerializer.Deserialize(JsonText, DurableAgentStateJsonContext.Default.DurableAgentState));
+    }
+
+    [Fact]
+    public void BreakingVersion()
+    {
+        // Arrange
+        const string JsonText = """
+            {
+                "schemaVersion": "2.0.0"
+            }
+            """;
+
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(
+            () => JsonSerializer.Deserialize(JsonText, DurableAgentStateJsonContext.Default.DurableAgentState));
+    }
+
+    [Fact]
+    public void MissingData()
+    {
+        // Arrange
+        const string JsonText = """
+            {
+                "schemaVersion": "1.0.0"
+            }
+            """;
+
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(
+            () => JsonSerializer.Deserialize(JsonText, DurableAgentStateJsonContext.Default.DurableAgentState));
+    }
+
+    [Fact]
+    public void ExtraData()
+    {
+        // Arrange
+        const string JsonText = """
+            {
+                "schemaVersion": "1.0.0",
+                "data": {
+                    "conversationHistory": [],
+                    "extraField": "someValue"
+                }
+            }
+            """;
+
+        // Act
+        DurableAgentState? state = JsonSerializer.Deserialize(JsonText, DurableAgentStateJsonContext.Default.DurableAgentState);
+
+        // Assert
+        Assert.NotNull(state?.Data?.ExtensionData);
+
+        Assert.True(state.Data.ExtensionData!.ContainsKey("extraField"));
+        Assert.Equal("someValue", state.Data.ExtensionData["extraField"]!.ToString());
+
+        // Act
+        string jsonState = JsonSerializer.Serialize(state, DurableAgentStateJsonContext.Default.DurableAgentState);
+        JsonDocument? jsonDocument = JsonSerializer.Deserialize<JsonDocument>(jsonState);
+
+        // Assert
+        Assert.NotNull(jsonDocument);
+        Assert.True(jsonDocument.RootElement.TryGetProperty("data", out JsonElement dataElement));
+        Assert.True(dataElement.TryGetProperty("extraField", out JsonElement extraFieldElement));
+        Assert.Equal("someValue", extraFieldElement.ToString());
+    }
+
+    [Fact]
+    public void BasicState()
+    {
+        // Arrange
+        const string JsonText = """
+          {
+              "schemaVersion": "1.0.0",
+              "data": {
+                  "conversationHistory": [
+                      {
+                          "$type": "request",
+                          "correlationId": "12345",
+                          "createdAt": "2024-01-01T12:00:00Z",
+                          "messages": [
+                              {
+                                  "role": "user",
+                                  "contents": [
+                                      {
+                                          "$type": "text",
+                                          "text": "Hello, agent!"
+                                      }
+                                  ]
+                              }
+                          ]
+                      },
+                      {
+                          "$type": "response",
+                          "correlationId": "12345",
+                          "createdAt": "2024-01-01T12:01:00Z",
+                          "messages": [
+                              {
+                                  "role": "agent",
+                                  "contents": [
+                                      {
+                                          "$type": "text",
+                                          "text": "Hi user!"
+                                      }
+                                  ]
+                              }
+                          ]
+                      }
+                  ]
+              }
+          }
+          """;
+
+        // Act
+        DurableAgentState? state = JsonSerializer.Deserialize(
+            JsonText,
+            DurableAgentStateJsonContext.Default.DurableAgentState);
+
+        // Assert
+        Assert.NotNull(state);
+        Assert.Equal("1.0.0", state.SchemaVersion);
+        Assert.NotNull(state.Data);
+
+        Assert.Collection(state.Data.ConversationHistory,
+            entry =>
+            {
+                Assert.IsType<DurableAgentStateRequest>(entry);
+                Assert.Equal("12345", entry.CorrelationId);
+                Assert.Equal(DateTimeOffset.Parse("2024-01-01T12:00:00Z"), entry.CreatedAt);
+                Assert.Single(entry.Messages);
+                Assert.Equal("user", entry.Messages[0].Role);
+                DurableAgentStateContent content = Assert.Single(entry.Messages[0].Contents);
+                DurableAgentStateTextContent textContent = Assert.IsType<DurableAgentStateTextContent>(content);
+                Assert.Equal("Hello, agent!", textContent.Text);
+            },
+            entry =>
+            {
+                Assert.IsType<DurableAgentStateResponse>(entry);
+                Assert.Equal("12345", entry.CorrelationId);
+                Assert.Equal(DateTimeOffset.Parse("2024-01-01T12:01:00Z"), entry.CreatedAt);
+                Assert.Single(entry.Messages);
+                Assert.Equal("agent", entry.Messages[0].Role);
+                Assert.Single(entry.Messages[0].Contents);
+                DurableAgentStateContent content = Assert.Single(entry.Messages[0].Contents);
+                DurableAgentStateTextContent textContent = Assert.IsType<DurableAgentStateTextContent>(content);
+                Assert.Equal("Hi user!", textContent.Text);
+            });
+    }
+}