chore: import upstream snapshot with attribution

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/DurableAgentStateResponseTests.cs

@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Agents.AI.DurableTask.State;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.DurableTask.Tests.Unit.State;
+
+public sealed class DurableAgentStateResponseTests
+{
+    [Fact]
+    public void FromResponseDropsMessagesContainingOnlyOpaqueContent()
+    {
+        // Arrange: one message with real text, one with only opaque AIContent
+        ChatMessage usefulMessage = new(ChatRole.Assistant, "Hello, world!")
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+        ChatMessage opaqueOnlyMessage = new(ChatRole.Assistant, [
+            new AIContent
+            {
+                RawRepresentation = new { kind = "sessionEvent", sessionId = "s123" }
+            }])
+        {
+            CreatedAt = DateTimeOffset.UtcNow.AddSeconds(1)
+        };
+
+        AgentResponse response = new(new List<ChatMessage> { usefulMessage, opaqueOnlyMessage })
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+
+        // Act
+        DurableAgentStateResponse durableResponse = DurableAgentStateResponse.FromResponse("corr-123", response);
+
+        // Assert: only the useful message survives
+        DurableAgentStateMessage durableMessage = Assert.Single(durableResponse.Messages);
+        Assert.Equal(ChatRole.Assistant.Value, durableMessage.Role);
+
+        // Round-trip to verify the content is correct
+        AgentResponse convertedResponse = durableResponse.ToResponse();
+        ChatMessage convertedMessage = Assert.Single(convertedResponse.Messages);
+        TextContent textContent = Assert.IsType<TextContent>(Assert.Single(convertedMessage.Contents));
+        Assert.Equal("Hello, world!", textContent.Text);
+    }
+
+    [Fact]
+    public void FromResponseKeepsMessagesWithMixedContent()
+    {
+        // Arrange: one message with both real text and opaque AIContent
+        ChatMessage mixedMessage = new(ChatRole.Assistant, [
+            new TextContent("Some useful text"),
+            new AIContent { RawRepresentation = new { kind = "metadata" } }])
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+
+        AgentResponse response = new(new List<ChatMessage> { mixedMessage })
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+
+        // Act
+        DurableAgentStateResponse durableResponse = DurableAgentStateResponse.FromResponse("corr-456", response);
+
+        // Assert: the message is kept because it contains at least one serializable content
+        DurableAgentStateMessage durableMessage = Assert.Single(durableResponse.Messages);
+        Assert.Equal(ChatRole.Assistant.Value, durableMessage.Role);
+    }
+
+    [Fact]
+    public void FromResponseDropsAllMessagesWhenAllAreOpaque()
+    {
+        // Arrange: all messages contain only opaque AIContent
+        ChatMessage opaque1 = new(ChatRole.Assistant, [
+            new AIContent { RawRepresentation = new { kind = "event1" } }])
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+        ChatMessage opaque2 = new(ChatRole.Assistant, [
+            new AIContent { RawRepresentation = new { kind = "event2" } }])
+        {
+            CreatedAt = DateTimeOffset.UtcNow.AddSeconds(1)
+        };
+
+        AgentResponse response = new(new List<ChatMessage> { opaque1, opaque2 })
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+
+        // Act
+        DurableAgentStateResponse durableResponse = DurableAgentStateResponse.FromResponse("corr-789", response);
+
+        // Assert: no messages stored
+        Assert.Empty(durableResponse.Messages);
+    }
+
+    [Fact]
+    public void FromResponseKeepsBaseAIContentWithAnnotations()
+    {
+        // Arrange: base AIContent with annotations should be kept
+        AIContent contentWithAnnotations = new()
+        {
+            RawRepresentation = new { kind = "event" },
+            Annotations = [new AIAnnotation() { AdditionalProperties = new() { ["cite"] = "ref-1" } }]
+        };
+        ChatMessage message = new(ChatRole.Assistant, [contentWithAnnotations])
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+
+        AgentResponse response = new([message]) { CreatedAt = DateTimeOffset.UtcNow };
+
+        // Act
+        DurableAgentStateResponse durableResponse = DurableAgentStateResponse.FromResponse("corr-ann", response);
+
+        // Assert: message is kept because the AIContent has annotations
+        Assert.Single(durableResponse.Messages);
+    }
+
+    [Fact]
+    public void FromResponseKeepsBaseAIContentWithAdditionalProperties()
+    {
+        // Arrange: base AIContent with additional properties should be kept
+        AIContent contentWithProps = new()
+        {
+            RawRepresentation = new { kind = "event" },
+            AdditionalProperties = new() { ["custom_key"] = "custom_value" }
+        };
+        ChatMessage message = new(ChatRole.Assistant, [contentWithProps])
+        {
+            CreatedAt = DateTimeOffset.UtcNow
+        };
+
+        AgentResponse response = new([message]) { CreatedAt = DateTimeOffset.UtcNow };
+
+        // Act
+        DurableAgentStateResponse durableResponse = DurableAgentStateResponse.FromResponse("corr-props", response);
+
+        // Assert: message is kept because the AIContent has additional properties
+        Assert.Single(durableResponse.Messages);
+    }
+}

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);
+            });
+    }
+}