Add streaming test

Author: kzu

src/Extensions.Grok/GrokChatClient.cs

@@ -1,5 +1,6 @@
 using System.Text.Json;
 using Devlooped.Grok;
+using Google.Protobuf;
 using Grpc.Core;
 using Grpc.Net.Client;
 using Microsoft.Extensions.AI;
@@ -95,22 +96,19 @@ public IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(IEnumerabl
         async IAsyncEnumerable<ChatResponseUpdate> CompleteChatStreamingCore(IEnumerable<ChatMessage> messages, ChatOptions? options, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
         {
             var requestDto = MapToRequest(messages, options);
-
-            using var call = client.GetCompletionChunk(requestDto, cancellationToken: cancellationToken);
-
+            var call = client.GetCompletionChunk(requestDto, cancellationToken: cancellationToken);
+            
             await foreach (var chunk in call.ResponseStream.ReadAllAsync(cancellationToken))
             {
                 var outputChunk = chunk.Outputs[0];
+                var text = outputChunk.Delta.Content is { Length: > 0 } delta ? delta : null;
 
                 // Use positional arguments for ChatResponseUpdate
-                var update = new ChatResponseUpdate(
-                    outputChunk.Delta.Role != MessageRole.InvalidRole ? MapRole(outputChunk.Delta.Role) : null,
-                    outputChunk.Delta.Content
-                )
+                var update = new ChatResponseUpdate(MapRole(outputChunk.Delta.Role), text)
                 {
                     ResponseId = chunk.Id,
                     ModelId = chunk.Model,
-                    CreatedAt = chunk.Created.ToDateTimeOffset(),
+                    CreatedAt = chunk.Created?.ToDateTimeOffset(),
                     FinishReason = outputChunk.FinishReason != FinishReason.ReasonInvalid ? MapFinishReason(outputChunk.FinishReason) : null,
                 };
 
@@ -129,7 +127,29 @@ async IAsyncEnumerable<ChatResponseUpdate> CompleteChatStreamingCore(IEnumerable
                     }
                 }
 
-                yield return update;
+                foreach (var toolCall in outputChunk.Delta.ToolCalls)
+                {
+                    if (toolCall.Type == ToolCallType.ClientSideTool)
+                    {
+                        var arguments = !string.IsNullOrEmpty(toolCall.Function.Arguments)
+                            ? JsonSerializer.Deserialize<IDictionary<string, object?>>(toolCall.Function.Arguments)
+                            : null;
+
+                        var content = new FunctionCallContent(
+                                toolCall.Id,
+                                toolCall.Function.Name,
+                                arguments);
+
+                        update.Contents.Add(content);
+                    }
+                    else
+                    {
+                        update.Contents.Add(new HostedToolCallContent(toolCall));
+                    }
+                }
+
+                if (update.Contents.Any())
+                    yield return update;
             }
         }
     }
@@ -221,6 +241,9 @@ GetCompletionsRequest MapToRequest(IEnumerable<ChatMessage> messages, ChatOption
             if (gmsg.Content.Count == 0 && gmsg.ToolCalls.Count == 0)
                 continue;
 
+            if (gmsg.Content.Count == 0)
+                gmsg.Content.Add(new Content());
+
             request.Messages.Add(gmsg);
         }
 

src/Tests/GrokTests.cs

@@ -1,4 +1,5 @@
-using System.Text.Json.Nodes;
+using System.Text.Json;
+using System.Text.Json.Nodes;
 using Azure;
 using Devlooped.Extensions.AI.Grok;
 using Microsoft.Extensions.AI;
@@ -319,4 +320,70 @@ public async Task GrokInvokesHostedMcp()
             response.Messages.SelectMany(x => x.Contents).OfType<HostedToolCallContent>(),
             x => x.ToolCall.Type == Devlooped.Grok.ToolCallType.McpTool);
     }
+
+    [SecretsFact("XAI_API_KEY", "GITHUB_TOKEN")]
+    public async Task GrokStreamsUpdatesFromAllTools()
+    {
+        var messages = new Chat()
+        {
+            { "user",
+                """
+                What's the oldest stable version released on the devlooped/GrokClient repo on GitHub?, 
+                what is the current price of Tesla stock, 
+                and what is the current date? Respond with the following JSON: 
+                {
+                  "today": "[get_date result]",
+                  "release": "[first stable release of devlooped/GrokClient]",
+                  "price": [$TSLA price]
+                }
+                """
+            },    
+        };
+
+        var grok = new GrokClient(Configuration["XAI_API_KEY"]!)
+            .AsIChatClient("grok-4-fast")
+            .AsBuilder()
+            .UseFunctionInvocation()
+            .UseLogging(output.AsLoggerFactory())
+            .Build();
+
+        var getDateCalls = 0;
+        var options = new ChatOptions
+        {
+            Tools =
+            [
+                new HostedWebSearchTool(),
+                new HostedMcpServerTool("GitHub", "https://api.githubcopilot.com/mcp/") {
+                    AuthorizationToken = Configuration["GITHUB_TOKEN"]!,
+                    AllowedTools = ["list_releases", "get_release_by_tag"],
+                },
+                AIFunctionFactory.Create(() => {
+                    getDateCalls++;
+                    return DateTimeOffset.Now.ToString("O");
+                }, "get_date", "Gets the current date")
+            ]
+        };
+
+        var updates = await grok.GetStreamingResponseAsync(messages, options).ToListAsync();
+        var response = updates.ToChatResponse();
+        var typed = JsonSerializer.Deserialize<Response>(response.Text, new JsonSerializerOptions(JsonSerializerDefaults.Web));
+
+        Assert.NotNull(typed);
+
+        Assert.Contains(
+            response.Messages.SelectMany(x => x.Contents).OfType<HostedToolCallContent>(),
+            x => x.ToolCall.Type == Devlooped.Grok.ToolCallType.McpTool);
+
+        Assert.Contains(
+            response.Messages.SelectMany(x => x.Contents).OfType<HostedToolCallContent>(),
+            x => x.ToolCall.Type == Devlooped.Grok.ToolCallType.WebSearchTool);
+
+        Assert.Equal(1, getDateCalls);
+
+        Assert.Equal(DateOnly.FromDateTime(DateTime.Today), typed.Today);
+        Assert.EndsWith("1.0.0", typed.Release);
+        Assert.True(typed.Price > 100);
+    }
+
+    record Response(DateOnly Today, string Release, decimal Price);
 }