Merge branch 'main' into copilot/fix-messageindex-cache-properties

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/06_LongRunningTools/Tools.cs

@@ -17,7 +17,7 @@ internal sealed class Tools(ILogger<Tools> logger)
     [Description("Starts a content generation workflow and returns the instance ID for tracking.")]
     public string StartContentGenerationWorkflow([Description("The topic for content generation")] string topic)
     {
-        this._logger.LogInformation("Starting content generation workflow for topic: {Topic}", topic);
+        this._logger.LogInformation("Starting content generation workflow for topic: {Topic}", SanitizeLogValue(topic));
 
         const int MaxReviewAttempts = 3;
         const float ApprovalTimeoutHours = 72;
@@ -34,7 +34,7 @@ internal sealed class Tools(ILogger<Tools> logger)
 
         this._logger.LogInformation(
             "Content generation workflow scheduled to be started for topic '{Topic}' with instance ID: {InstanceId}",
-            topic,
+            SanitizeLogValue(topic),
             instanceId);
 
         return $"Workflow started with instance ID: {instanceId}";
@@ -45,7 +45,7 @@ internal sealed class Tools(ILogger<Tools> logger)
         [Description("The instance ID of the workflow to check")] string instanceId,
         [Description("Whether to include detailed information")] bool includeDetails = true)
     {
-        this._logger.LogInformation("Getting status for workflow instance: {InstanceId}", instanceId);
+        this._logger.LogInformation("Getting status for workflow instance: {InstanceId}", SanitizeLogValue(instanceId));
 
         // Get the current agent context using the session-static property
         OrchestrationMetadata? status = await DurableAgentContext.Current.GetOrchestrationStatusAsync(
@@ -54,7 +54,7 @@ internal sealed class Tools(ILogger<Tools> logger)
 
         if (status is null)
         {
-            this._logger.LogInformation("Workflow instance '{InstanceId}' not found.", instanceId);
+            this._logger.LogInformation("Workflow instance '{InstanceId}' not found.", SanitizeLogValue(instanceId));
             return new
             {
                 instanceId,
@@ -78,7 +78,16 @@ internal sealed class Tools(ILogger<Tools> logger)
         [Description("The instance ID of the workflow to submit feedback for")] string instanceId,
         [Description("Feedback to submit")] HumanApprovalResponse feedback)
     {
-        this._logger.LogInformation("Submitting human approval for workflow instance: {InstanceId}", instanceId);
+        this._logger.LogInformation("Submitting human approval for workflow instance: {InstanceId}", SanitizeLogValue(instanceId));
         await DurableAgentContext.Current.RaiseOrchestrationEventAsync(instanceId, "HumanApproval", feedback);
     }
+
+    /// <summary>
+    /// Sanitizes a user-provided value for safe inclusion in log entries
+    /// by removing control characters that could be used for log forging.
+    /// </summary>
+    private static string SanitizeLogValue(string value) =>
+        value
+            .Replace("\r", string.Empty, StringComparison.Ordinal)
+            .Replace("\n", string.Empty, StringComparison.Ordinal);
 }

dotnet/samples/04-hosting/DurableAgents/AzureFunctions/08_ReliableStreaming/FunctionTriggers.cs

@@ -157,8 +157,8 @@ public sealed class FunctionTriggers
 
         this._logger.LogInformation(
             "Resuming stream for conversation {ConversationId} from cursor: {Cursor}",
-            conversationId,
-            cursor ?? "(beginning)");
+            SanitizeLogValue(conversationId),
+            SanitizeLogValue(cursor) ?? "(beginning)");
 
         // Check Accept header to determine response format
         // text/plain = raw text output (ideal for terminals)
@@ -205,7 +205,7 @@ public sealed class FunctionTriggers
             {
                 if (chunk.Error != null)
                 {
-                    this._logger.LogWarning("Stream error for conversation {ConversationId}: {Error}", conversationId, chunk.Error);
+                    this._logger.LogWarning("Stream error for conversation {ConversationId}: {Error}", SanitizeLogValue(conversationId), chunk.Error);
                     await WriteErrorAsync(httpContext.Response, chunk.Error, useSseFormat, cancellationToken);
                     break;
                 }
@@ -224,7 +224,7 @@ public sealed class FunctionTriggers
         }
         catch (OperationCanceledException)
         {
-            this._logger.LogInformation("Client disconnected from stream {ConversationId}", conversationId);
+            this._logger.LogInformation("Client disconnected from stream {ConversationId}", SanitizeLogValue(conversationId));
         }
 
         return new EmptyResult();
@@ -316,4 +316,20 @@ public sealed class FunctionTriggers
 
         await response.WriteAsync(sb.ToString());
     }
+
+    /// <summary>
+    /// Sanitizes a user-provided value for safe inclusion in log entries
+    /// by removing control characters that could be used for log forging.
+    /// </summary>
+    private static string? SanitizeLogValue(string? value)
+    {
+        if (value is null)
+        {
+            return null;
+        }
+
+        return value
+            .Replace("\r", string.Empty, StringComparison.Ordinal)
+            .Replace("\n", string.Empty, StringComparison.Ordinal);
+    }
 }

dotnet/samples/05-end-to-end/HostedAgents/AgentWithHostedMCP/Program.cs

@@ -4,6 +4,9 @@
 // In this case the OpenAI responses service will invoke any MCP tools as required. MCP tools are not invoked by the Agent Framework.
 // The sample demonstrates how to use MCP tools with auto approval by setting ApprovalMode to NeverRequire.
 
+#pragma warning disable MEAI001 // HostedMcpServerTool, HostedMcpServerToolApprovalMode are experimental
+#pragma warning disable OPENAI001 // GetResponsesClient is experimental
+
 using Azure.AI.AgentServer.AgentFramework.Extensions;
 using Azure.AI.OpenAI;
 using Azure.Identity;

dotnet/samples/05-end-to-end/HostedAgents/FoundryMultiAgent/Program.cs

@@ -3,6 +3,8 @@
 // This sample demonstrates a multi-agent workflow with Writer and Reviewer agents
 // using Azure AI Foundry AIProjectClient and the Agent Framework WorkflowBuilder.
 
+#pragma warning disable CA2252 // AIProjectClient and Agents API require opting into preview features
+
 using Azure.AI.AgentServer.AgentFramework.Extensions;
 using Azure.AI.Projects;
 using Azure.Identity;

dotnet/samples/05-end-to-end/HostedAgents/FoundrySingleAgent/Program.cs

@@ -4,6 +4,8 @@
 // Uses Microsoft Agent Framework with Azure AI Foundry.
 // Ready for deployment to Foundry Hosted Agent service.
 
+#pragma warning disable CA2252 // AIProjectClient and Agents API require opting into preview features
+
 using System.ComponentModel;
 using System.Globalization;
 using System.Text;

dotnet/src/Microsoft.Agents.AI.DurableTask/CHANGELOG.md

@@ -4,6 +4,12 @@
 
 ### Changed
 
+- Filter empty `AIContent` from durable agent state responses ([#4670](https://github.com/microsoft/agent-framework/pull/4670))
+
+## v1.0.0-preview.260311.1
+
+### Changed
+
 - Added TTL configuration for durable agent entities ([#2679](https://github.com/microsoft/agent-framework/pull/2679))
 - Switch to new "Run" method name ([#2843](https://github.com/microsoft/agent-framework/pull/2843))
 - Removed AgentThreadMetadata and used AgentSessionId directly instead ([#3067](https://github.com/microsoft/agent-framework/pull/3067));
@@ -16,6 +22,8 @@
 - Marked all `RunAsync<T>` overloads as `new`, added missing ones, and added support for primitives and arrays ([#3803](https://github.com/microsoft/agent-framework/pull/3803))
 - Improve session cast error message quality and consistency ([#3973](https://github.com/microsoft/agent-framework/pull/3973))
 
+NOTE: Some of the above changes may have been part of earlier releases not mentioned in this file.
+
 ## v1.0.0-preview.251204.1
 
 - Added orchestration ID to durable agent entity state ([#2137](https://github.com/microsoft/agent-framework/pull/2137))

dotnet/src/Microsoft.Agents.AI.DurableTask/State/DurableAgentStateResponse.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using System.Text.Json.Serialization;
+using Microsoft.Extensions.AI;
 
 namespace Microsoft.Agents.AI.DurableTask.State;
 
@@ -28,7 +29,10 @@ internal sealed class DurableAgentStateResponse : DurableAgentStateEntry
         {
             CorrelationId = correlationId,
             CreatedAt = response.CreatedAt ?? response.Messages.Max(m => m.CreatedAt) ?? DateTimeOffset.UtcNow,
-            Messages = response.Messages.Select(DurableAgentStateMessage.FromChatMessage).ToList(),
+            Messages = response.Messages
+                .Where(HasSerializableContent)
+                .Select(DurableAgentStateMessage.FromChatMessage)
+                .ToList(),
             Usage = DurableAgentStateUsage.FromUsage(response.Usage)
         };
     }
@@ -46,4 +50,18 @@ internal sealed class DurableAgentStateResponse : DurableAgentStateEntry
             Usage = this.Usage?.ToUsageDetails(),
         };
     }
+
+    // Checks whether a ChatMessage has any content that will produce meaningful serialized data.
+    // Known derived AIContent types (TextContent, FunctionCallContent, etc.) are always serializable.
+    // Base AIContent instances only carry RawRepresentation (which is [JsonIgnore]), Annotations, and
+    // AdditionalProperties. We keep the message if any base AIContent has annotations or additional
+    // properties set. NOTE: if AIContent gains new serializable properties in the future, this check
+    // should be updated accordingly.
+    private static bool HasSerializableContent(ChatMessage message)
+    {
+        return message.Contents.Any(c =>
+            c.GetType() != typeof(AIContent) ||
+            c.Annotations?.Count > 0 ||
+            c.AdditionalProperties?.Count > 0);
+    }
 }

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