NexusChat

public interface IAIService
{
    IAsyncEnumerable<string> StreamCompletionAsync(
        ConversationContext context, 
        CancellationToken cancellationToken = default
    );
    
    Task<ModelCapabilities> GetCapabilitiesAsync();
}

public sealed class OpenAiService(HttpClient httpClient, string apiKey) : IAIService
{
    public async IAsyncEnumerable<string> StreamCompletionAsync(
        ConversationContext context, 
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        var request = new HttpRequestMessage(HttpMethod.Post, "https://api.openai.com/v1/chat/completions")
        {
            Content = JsonContent.Create(new
            {
                model = context.ModelName,
                messages = context.Messages,
                stream = true
            })
        };
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

        using var response = await httpClient.SendAsync(
            request, 
            HttpCompletionOption.ResponseHeadersRead, 
            cancellationToken
        );
        response.EnsureSuccessStatusCode();

        using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
        using var reader = new StreamReader(stream);

        while (!reader.EndOfStream && !cancellationToken.IsCancellationRequested)
        {
            var line = await reader.ReadLineAsync(cancellationToken);
            if (string.IsNullOrWhiteSpace(line) || !line.StartsWith("data: ")) continue;
            if (line.Contains("[DONE]")) break;

            var json = line["data: ".Length..];
            using var doc = JsonDocument.Parse(json);
            var delta = doc.RootElement
                .GetProperty("choices")[0]
                .GetProperty("delta");

            if (delta.TryGetProperty("content", out var contentElement))
            {
                var content = contentElement.GetString();
                if (!string.IsNullOrEmpty(content)) yield return content;
            }
        }
    }

    public Task<ModelCapabilities> GetCapabilitiesAsync() => 
        Task.FromResult(new ModelCapabilities(SupportsStreaming: true, SupportsVision: true, MaxContextTokens: 128_000));
}

public partial class ChatViewModel : ObservableObject
{
    private readonly IAIServiceFactory serviceFactory;
    private readonly IConversationRepository conversationRepo;

    [ObservableProperty]
    private string inputMessage = string.Empty;

    [ObservableProperty]
    private bool isStreaming;

    public ObservableCollection<ChatMessage> Messages { get; } = [];

    public ChatViewModel(IAIServiceFactory serviceFactory, IConversationRepository conversationRepo)
    {
        this.serviceFactory = serviceFactory;
        this.conversationRepo = conversationRepo;
    }

    [RelayCommand(CanExecute = nameof(CanSendMessage))]
    private async Task SendMessageAsync(CancellationToken ct)
    {
        var userText = InputMessage.Trim();
        InputMessage = string.Empty;

        var userMessage = new ChatMessage(Role.User, userText, DateTime.UtcNow);
        Messages.Add(userMessage);

        var assistantMessage = new ChatMessage(Role.Assistant, string.Empty, DateTime.UtcNow);
        Messages.Add(assistantMessage);

        IsStreaming = true;
        try
        {
            var service = serviceFactory.GetProvider("OpenAI");
            var context = new ConversationContext("gpt-4o", Messages);

            await foreach (var token in service.StreamCompletionAsync(context, ct))
            {
                assistantMessage.Content += token;
            }
        }
        finally
        {
            IsStreaming = false;
            await conversationRepo.SaveMessageAsync(assistantMessage);
        }
    }

    private bool CanSendMessage() => !string.IsNullOrWhiteSpace(InputMessage) && !IsStreaming;
}