.Net: Fix Gemini Auto Invoke when returned function is non-first part (#12174)

### Motivation and Context

<!-- Thank you for your contribution to the semantic-kernel repo!
Please help reviewers and future users, providing the following
information:
  1. Why is this change required?
  2. What problem does it solve?
  3. What scenario does it contribute to?
  4. If it fixes an open issue, please link to the issue here.
-->

Fixes #11651 

- Currently Gemini Connectors will not Auto invoke functions when tool
calls are returned in the same message with text parts, which is common
with 2.5 Flash and Pro models:
```json
"content": {
  "parts": [
    {
      "text": "Running the TimePlugin.Now function..."
    },
    {
      "functionCall": {
        "name": "TimePlugin.Now",
        "args": {
          "param1": "hello"
        }
      }
    }
  ],
  "role": "model"
}
```

This fixes this to now support auto kernel functions with this behavior
and adds unit tests with this data.

### Description

<!-- Describe your changes, the overall approach, the underlying design.
These notes will help understanding how your code works. Thanks! -->

- Added unit test data for streaming responses with text & tool parts
- Changed `GetChatMessageContentFromCandidate` to return tools from all
candidate parts instead of only the first part
- Added extra check in `GenerateChatMessageAsync` for empty Tool results
- Fixed stream responses in auto invoke mode with texts & tool parts not
returned to the caller, added unit test

### Contribution Checklist

<!-- Before submitting this PR, please make sure: -->

- [x] The code builds clean without any errors or warnings
- [x] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [x] All unit tests pass, and I have added new tests where possible
- [x] I didn't break anyone 😄

---------

Co-authored-by: Roger Barreto <[email protected]>

Author: ionite34

dotnet/src/Connectors/Connectors.Google.UnitTests/Core/Gemini/Clients/GeminiChatStreamingFunctionCallingTests.cs

@@ -272,6 +272,35 @@ await client.StreamGenerateChatMessageAsync(chatHistory, executionSettings: exec
             Assert.False(string.IsNullOrWhiteSpace(item.Content)));
     }
 
+    [Fact]
+    public async Task IfAutoInvokeShouldReturnAssistantToolCallMessagesWithTextAsync()
+    {
+        // Arrange
+        using var handlerStub = new MultipleHttpMessageHandlerStub();
+        handlerStub.AddJsonResponse(this._responseContentWithFunction);
+        handlerStub.AddJsonResponse(this._responseContent);
+#pragma warning disable CA2000
+        var client = this.CreateChatCompletionClient(httpClient: handlerStub.CreateHttpClient());
+#pragma warning restore CA2000
+        var chatHistory = CreateSampleChatHistory();
+        var executionSettings = new GeminiPromptExecutionSettings
+        {
+            ToolCallBehavior = GeminiToolCallBehavior.AutoInvokeKernelFunctions
+        };
+
+        // Act
+        var messages =
+            await client.StreamGenerateChatMessageAsync(chatHistory, executionSettings: executionSettings, kernel: this._kernelWithFunctions)
+                .ToListAsync();
+
+        // Assert
+        var firstMessage = (GeminiStreamingChatMessageContent?)messages.FirstOrDefault();
+        Assert.NotNull(firstMessage?.ToolCalls);
+        Assert.Single(firstMessage.ToolCalls,
+            item => item.FullyQualifiedName == this._timePluginNow.FullyQualifiedName);
+        Assert.False(string.IsNullOrWhiteSpace(firstMessage.Content));
+    }
+
     [Fact]
     public async Task IfAutoInvokeShouldPassToolsToEachRequestAsync()
     {

dotnet/src/Connectors/Connectors.Google.UnitTests/TestData/chat_one_function_response.json

@@ -3,6 +3,9 @@
     {
       "content": {
         "parts": [
+          {
+            "text": "Running the TimePlugin.Now function..."
+          },
           {
             "functionCall": {
               "name": "TimePlugin%nameSeparator%Now",

dotnet/src/Connectors/Connectors.Google/Core/Gemini/Clients/GeminiChatCompletionClient.cs

@@ -197,7 +197,7 @@ public async Task<IReadOnlyList<ChatMessageContent>> GenerateChatMessageAsync(
             }
 
             state.LastMessage = chatResponses[0];
-            if (state.LastMessage.ToolCalls is null)
+            if (state.LastMessage.ToolCalls is null || state.LastMessage.ToolCalls.Count == 0)
             {
                 return chatResponses;
             }
@@ -356,12 +356,16 @@ private async IAsyncEnumerable<StreamingChatMessageContent> GetStreamingChatMess
 
                     // If function call was returned there is no more data in stream
                     state.LastMessage = messageContent;
+
+                    // Yield the message also if it contains text
+                    if (!string.IsNullOrWhiteSpace(messageContent.Content))
+                    {
+                        yield return this.GetStreamingChatContentFromChatContent(messageContent);
+                    }
+
                     yield break;
                 }
 
-                // We disable auto-invoke because the first message in the stream doesn't contain ToolCalls or auto-invoke is already false
-                state.AutoInvoke = false;
-
                 // If we don't want to attempt to invoke any functions, just return the result.
                 yield return this.GetStreamingChatContentFromChatContent(messageContent);
             }
@@ -604,11 +608,17 @@ [new GeminiChatMessageContent(role: AuthorRole.Assistant, content: string.Empty,
 
     private GeminiChatMessageContent GetChatMessageContentFromCandidate(GeminiResponse geminiResponse, GeminiResponseCandidate candidate)
     {
-        GeminiPart? part = candidate.Content?.Parts?[0];
-        GeminiPart.FunctionCallPart[]? toolCalls = part?.FunctionCall is { } function ? [function] : null;
+        // Join text parts
+        string text = string.Concat(candidate.Content?.Parts?.Select(part => part.Text) ?? []);
+
+        // Gemini sometimes returns function calls with text parts, so collect them
+        var toolCalls = candidate.Content?.Parts?
+            .Select(part => part.FunctionCall!)
+            .Where(toolCall => toolCall is not null).ToArray();
+
         return new GeminiChatMessageContent(
             role: candidate.Content?.Role ?? AuthorRole.Assistant,
-            content: part?.Text ?? string.Empty,
+            content: text,
             modelId: this._modelId,
             functionsToolCalls: toolCalls,
             metadata: GetResponseMetadata(geminiResponse, candidate));