.NET: Improve fidelity of OpenAI ChatCompletions Hosting

dotnet/samples/AgentWebChat/AgentWebChat.AgentHost/Program.cs

@@ -80,6 +80,8 @@ Once the user has deduced what type (knight or knave) both Alice and Bob are, te
 
 builder.AddSequentialWorkflow("science-sequential-workflow", [chemistryAgent, mathsAgent, literatureAgent]).AddAsAIAgent();
 builder.AddConcurrentWorkflow("science-concurrent-workflow", [chemistryAgent, mathsAgent, literatureAgent]).AddAsAIAgent();
+
+builder.AddOpenAIChatCompletions();
 builder.AddOpenAIResponses();
 
 var app = builder.Build();

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/ChatCompletions/AIAgentChatCompletionsProcessor.cs

@@ -1,70 +1,44 @@
 // Copyright (c) Microsoft. All rights reserved.
 
-using System.Buffers;
-using System.ClientModel.Primitives;
+using System;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Linq;
 using System.Net.ServerSentEvents;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Agents.AI.Hosting.OpenAI.ChatCompletions.Utils;
+using Microsoft.Agents.AI.Hosting.OpenAI.ChatCompletions.Converters;
+using Microsoft.Agents.AI.Hosting.OpenAI.ChatCompletions.Models;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
-using OpenAI.Chat;
-using ChatMessage = Microsoft.Extensions.AI.ChatMessage;
+using Microsoft.Extensions.AI;
 
 namespace Microsoft.Agents.AI.Hosting.OpenAI.ChatCompletions;
 
-internal sealed class AIAgentChatCompletionsProcessor
+internal static class AIAgentChatCompletionsProcessor
 {
-    private readonly AIAgent _agent;
-
-    public AIAgentChatCompletionsProcessor(AIAgent agent)
+    public static async Task<IResult> CreateChatCompletionAsync(AIAgent agent, CreateChatCompletion request, CancellationToken cancellationToken)
     {
-        this._agent = agent;
-    }
+        ArgumentNullException.ThrowIfNull(agent);
 
-    public async Task<IResult> CreateChatCompletionAsync(ChatCompletionOptions chatCompletionOptions, CancellationToken cancellationToken)
-    {
-        AgentThread? agentThread = null; // not supported to resolve from conversationId
+        var chatMessages = request.Messages.Select(i => i.ToChatMessage());
+        var chatClientAgentRunOptions = request.BuildOptions();
 
-        var inputItems = chatCompletionOptions.GetMessages();
-        var chatMessages = inputItems.AsChatMessages();
-
-        if (chatCompletionOptions.GetStream())
+        if (request.Stream == true)
         {
-            return new OpenAIStreamingChatCompletionResult(this._agent, chatMessages);
+            return new StreamingResponse(agent, request, chatMessages, chatClientAgentRunOptions);
         }
 
-        var agentResponse = await this._agent.RunAsync(chatMessages, agentThread, cancellationToken: cancellationToken).ConfigureAwait(false);
-        return new OpenAIChatCompletionResult(agentResponse);
-    }
-
-    private sealed class OpenAIChatCompletionResult(AgentRunResponse agentRunResponse) : IResult
-    {
-        public async Task ExecuteAsync(HttpContext httpContext)
-        {
-            // note: OpenAI SDK types provide their own serialization implementation
-            // so we cant simply return IResult wrap for the typed-object.
-            // instead writing to the response body can be done.
-
-            var cancellationToken = httpContext.RequestAborted;
-            var response = httpContext.Response;
-
-            var chatResponse = agentRunResponse.AsChatResponse();
-            var openAIChatCompletion = chatResponse.AsOpenAIChatCompletion();
-            var openAIChatCompletionJsonModel = openAIChatCompletion as IJsonModel<ChatCompletion>;
-            Debug.Assert(openAIChatCompletionJsonModel is not null);
-
-            var writer = new Utf8JsonWriter(response.BodyWriter, new JsonWriterOptions { SkipValidation = false });
-            openAIChatCompletionJsonModel.Write(writer, ModelReaderWriterOptions.Json);
-            await writer.FlushAsync(cancellationToken).ConfigureAwait(false);
-        }
+        var response = await agent.RunAsync(chatMessages, options: chatClientAgentRunOptions, cancellationToken: cancellationToken).ConfigureAwait(false);
+        return Results.Ok(response.ToChatCompletion(request));
     }
 
-    private sealed class OpenAIStreamingChatCompletionResult(AIAgent agent, IEnumerable<ChatMessage> chatMessages) : IResult
+    private sealed class StreamingResponse(
+        AIAgent agent,
+        CreateChatCompletion request,
+        IEnumerable<ChatMessage> chatMessages,
+        ChatClientAgentRunOptions? options) : IResult
     {
         public Task ExecuteAsync(HttpContext httpContext)
         {
@@ -79,26 +53,77 @@ public Task ExecuteAsync(HttpContext httpContext)
             httpContext.Features.GetRequiredFeature<IHttpResponseBodyFeature>().DisableBuffering();
 
             return SseFormatter.WriteAsync(
-                source: this.GetStreamingResponsesAsync(cancellationToken),
+                source: this.GetStreamingChunksAsync(cancellationToken),
                 destination: response.Body,
                 itemFormatter: (sseItem, bufferWriter) =>
                 {
-                    var sseDataJsonModel = (IJsonModel<StreamingChatCompletionUpdate>)sseItem.Data;
-                    var json = sseDataJsonModel.Write(ModelReaderWriterOptions.Json);
-                    bufferWriter.Write(json);
+                    using var writer = new Utf8JsonWriter(bufferWriter);
+                    JsonSerializer.Serialize(writer, sseItem.Data, ChatCompletionsJsonContext.Default.ChatCompletionChunk);
+                    writer.Flush();
                 },
                 cancellationToken);
         }
 
-        private async IAsyncEnumerable<SseItem<StreamingChatCompletionUpdate>> GetStreamingResponsesAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)
+        private async IAsyncEnumerable<SseItem<ChatCompletionChunk>> GetStreamingChunksAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
-            AgentThread? agentThread = null;
+            // The Unix timestamp (in seconds) of when the chat completion was created. Each chunk has the same timestamp.
+            DateTimeOffset? createdAt = null;
 
-            var agentRunResponseUpdates = agent.RunStreamingAsync(chatMessages, thread: agentThread, cancellationToken: cancellationToken);
-            var chatResponseUpdates = agentRunResponseUpdates.AsChatResponseUpdatesAsync();
-            await foreach (var streamingChatCompletionUpdate in chatResponseUpdates.AsOpenAIStreamingChatCompletionUpdatesAsync(cancellationToken).ConfigureAwait(false))
+            await foreach (var agentRunResponseUpdate in agent.RunStreamingAsync(chatMessages, options: options, cancellationToken: cancellationToken).WithCancellation(cancellationToken))
             {
-                yield return new SseItem<StreamingChatCompletionUpdate>(streamingChatCompletionUpdate);
+                var choiceChunks = new List<ChatCompletionChoiceChunk>();
+                CompletionUsage? usageDetails = null;
+
+                createdAt ??= agentRunResponseUpdate.CreatedAt;
+
+                foreach (var content in agentRunResponseUpdate.Contents)
+                {
+                    // usage content is handled separately
+                    if (content is UsageContent usageContent && usageContent.Details != null)
+                    {
+                        usageDetails = usageContent.Details.ToCompletionUsage();
+                        continue;
+                    }
+
+                    ChatCompletionDelta delta = content switch
+                    {
+                        TextContent textContent => new() { Content = textContent.Text },
+
+                        // image
+                        DataContent imageContent when imageContent.HasTopLevelMediaType("image") => new() { Content = imageContent.Base64Data.ToString() },
+                        UriContent urlContent when urlContent.HasTopLevelMediaType("image") => new() { Content = urlContent.Uri.ToString() },
+
+                        // audio
+                        DataContent audioContent when audioContent.HasTopLevelMediaType("audio") => new() { Content = audioContent.Base64Data.ToString() },
+
+                        // file
+                        DataContent fileContent when !fileContent.HasTopLevelMediaType("image") && !fileContent.HasTopLevelMediaType("audio")
+                            => new() { Content = fileContent.Base64Data.ToString() },
+                        HostedFileContent fileContent => new() { Content = fileContent.FileId },
+
+                        _ => throw new InvalidOperationException($"Got unsupported content: {content.GetType()}")
+                    };
+                    delta.Role = agentRunResponseUpdate.Role?.Value ?? "user";
+
+                    var choiceChunk = new ChatCompletionChoiceChunk
+                    {
+                        Index = 0,
+                        Delta = delta
+                    };
+
+                    choiceChunks.Add(choiceChunk);
+                }
+
+                var chunk = new ChatCompletionChunk
+                {
+                    Id = IdGeneratorHelpers.NewId(prefix: "chatcmpl", delimiter: "-", stringLength: 13),
+                    Created = (createdAt ?? DateTimeOffset.UtcNow).ToUnixTimeSeconds(),
+                    Model = request.Model,
+                    Choices = choiceChunks,
+                    Usage = usageDetails
+                };
+
+                yield return new(chunk);
             }
         }
     }

dotnet/src/Microsoft.Agents.AI.Hosting.OpenAI/ChatCompletions/AgentRunResponseExtensions.cs

@@ -0,0 +1,174 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Agents.AI.Hosting.OpenAI.ChatCompletions.Models;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hosting.OpenAI.ChatCompletions;
+
+/// <summary>
+/// Extension methods for converting agent responses to ChatCompletion models.
+/// </summary>
+internal static class AgentRunResponseExtensions
+{
+    public static ChatCompletion ToChatCompletion(this AgentRunResponse agentRunResponse, CreateChatCompletion request)
+    {
+        IList<ChatCompletionChoice> choices = agentRunResponse.ToChoices();
+
+        return new ChatCompletion
+        {
+            Id = IdGeneratorHelpers.NewId(prefix: "chatcmpl", delimiter: "-", stringLength: 13),
+            Choices = choices,
+            Created = (agentRunResponse.CreatedAt ?? DateTimeOffset.UtcNow).ToUnixTimeSeconds(),
+            Model = /* request.Agent?.Name ?? */ request.Model,
+            Usage = agentRunResponse.Usage.ToCompletionUsage(),
+            ServiceTier = request.ServiceTier ?? "default"
+        };
+    }
+
+    public static List<ChatCompletionChoice> ToChoices(this AgentRunResponse agentRunResponse)
+    {
+        var chatCompletionChoices = new List<ChatCompletionChoice>();
+        var index = 0;
+
+        foreach (var message in agentRunResponse.Messages)
+        {
+            foreach (var content in message.Contents)
+            {
+                ChoiceMessage choiceMessage = content switch
+                {
+                    // text
+                    TextContent textContent => new()
+                    {
+                        Content = textContent.Text
+                    },
+
+                    // image, see how MessageContentPartConverter packs the content types
+                    DataContent imageContent when imageContent.HasTopLevelMediaType("image") => new()
+                    {
+                        Content = imageContent.Base64Data.ToString()
+                    },
+                    UriContent urlContent when urlContent.HasTopLevelMediaType("image") => new()
+                    {
+                        Content = urlContent.Uri.ToString()
+                    },
+
+                    // audio
+                    DataContent audioContent when audioContent.HasTopLevelMediaType("audio") => new()
+                    {
+                        Audio = new()
+                        {
+                            Data = audioContent.Base64Data.ToString(),
+                            Id = audioContent.Name,
+                            //Transcript = ,
+                            //ExpiresAt = ,
+                        },
+                    },
+
+                    // file (neither audio nor image)
+                    DataContent fileContent => new()
+                    {
+                        Content = fileContent.Base64Data.ToString()
+                    },
+                    HostedFileContent fileContent => new()
+                    {
+                        Content = fileContent.FileId
+                    },
+
+                    _ => throw new InvalidOperationException($"Got unsupported content: {content.GetType()}")
+                };
+
+                choiceMessage.Role = message.Role.Value;
+                choiceMessage.Annotations = content.Annotations?.ToChoiceMessageAnnotations();
+
+                var choice = new ChatCompletionChoice
+                {
+                    Index = index++,
+                    Message = choiceMessage
+                };
+
+                chatCompletionChoices.Add(choice);
+            }
+        }
+
+        return chatCompletionChoices;
+    }
+
+    /// <summary>
+    /// Converts UsageDetails to ResponseUsage.
+    /// </summary>
+    /// <param name="usage">The usage details to convert.</param>
+    /// <returns>A ResponseUsage object with zeros if usage is null.</returns>
+    public static CompletionUsage ToCompletionUsage(this UsageDetails? usage)
+    {
+        if (usage == null)
+        {
+            return CompletionUsage.Zero;
+        }
+
+        var cachedTokens = usage.AdditionalCounts?.TryGetValue("InputTokenDetails.CachedTokenCount", out var cachedInputToken) ?? false
+            ? (int)cachedInputToken
+            : 0;
+        var reasoningTokens =
+            usage.AdditionalCounts?.TryGetValue("OutputTokenDetails.ReasoningTokenCount", out var reasoningToken) ?? false
+                ? (int)reasoningToken
+                : 0;
+
+        return new CompletionUsage
+        {
+            PromptTokens = (int)(usage.InputTokenCount ?? 0),
+            PromptTokensDetails = new() { CachedTokens = cachedTokens },
+            CompletionTokens = (int)(usage.OutputTokenCount ?? 0),
+            CompletionTokensDetails = new() { ReasoningTokens = reasoningTokens },
+            TotalTokens = (int)(usage.TotalTokenCount ?? 0)
+        };
+    }
+
+    public static IList<ChoiceMessageAnnotation> ToChoiceMessageAnnotations(this IList<AIAnnotation> annotations)
+    {
+        var result = new List<ChoiceMessageAnnotation>();
+        foreach (var annotation in annotations.OfType<CitationAnnotation>())
+        {
+            if (annotation is null)
+            {
+                continue;
+            }
+
+            // may point to mulitple regions in the AIContent.
+            // we need to unroll another loop for regions then -> chatCompletions only point to single region per annotation
+
+            var regions = annotation.AnnotatedRegions?.OfType<TextSpanAnnotatedRegion>().Where(x => x.StartIndex is not null && x.EndIndex is not null);
+            if (regions is not null)
+            {
+                foreach (var region in regions)
+                {
+                    result.Add(new()
+                    {
+                        AnnotationUrlCitation = new AnnotationUrlCitation
+                        {
+                            Url = annotation.Url?.ToString(),
+                            Title = annotation.Title,
+                            StartIndex = region.StartIndex,
+                            EndIndex = region.EndIndex
+                        }
+                    });
+                }
+            }
+            else
+            {
+                result.Add(new()
+                {
+                    AnnotationUrlCitation = new AnnotationUrlCitation
+                    {
+                        Url = annotation.Url?.ToString(),
+                        Title = annotation.Title
+                    }
+                });
+            }
+        }
+
+        return result;
+    }
+}