.Net: Fix bug where invoking with no message throws for some agents. (microsoft#11217)

### Motivation and Context

We were relying on the thread being created when we added messages to it
the first time, but in some cases no messages will be added, since the
agent could be invoked with no messages.

### Description

Fix bug where invoking with no message throws for some agents.

### Contribution Checklist

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

- [ ] The code builds clean without any errors or warnings
- [ ] 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
- [ ] All unit tests pass, and I have added new tests where possible
- [ ] I didn't break anyone 😄

Author: westey-m

dotnet/src/Agents/Abstractions/Agent.cs

@@ -198,6 +198,12 @@ protected virtual async Task<TThreadType> EnsureThreadExistsWithMessagesAsync<TT
             throw new KernelException($"{this.GetType().Name} currently only supports agent threads of type {nameof(TThreadType)}.");
         }
 
+        // We have to explicitly call create here to ensure that the thread is created
+        // before we invoke using the thread. While threads will be created when
+        // notified of new messages, some agents support invoking without a message,
+        // and in that case no messages will be sent in the next step.
+        await thread.CreateAsync(cancellationToken).ConfigureAwait(false);
+
         // Notify the thread that new messages are available.
         foreach (var message in messages)
         {

dotnet/src/Agents/Abstractions/AgentThread.cs

@@ -32,7 +32,7 @@ public abstract class AgentThread
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task that completes when the thread has been created.</returns>
     /// <exception cref="InvalidOperationException">The thread has been deleted.</exception>
-    protected virtual async Task CreateAsync(CancellationToken cancellationToken = default)
+    protected internal virtual async Task CreateAsync(CancellationToken cancellationToken = default)
     {
         if (this.IsDeleted)
         {

dotnet/src/IntegrationTests/Agents/CommonInterfaceConformance/InvokeConformance/BedrockAgentInvokeTests.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using System;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.SemanticKernel;
@@ -40,6 +41,13 @@ public override Task InvokeWithoutThreadCreatesThreadAsync()
         return base.InvokeWithoutThreadCreatesThreadAsync();
     }
 
+    [Fact(Skip = "This test is for manual verification.")]
+    public override Task InvokeWithoutMessageCreatesThreadAsync()
+    {
+        // The Bedrock agent does not support invoking without a message.
+        return Assert.ThrowsAsync<InvalidOperationException>(async () => await base.InvokeWithoutThreadCreatesThreadAsync());
+    }
+
     [Fact(Skip = "This test is for manual verification.")]
     public override Task MultiStepInvokeWithPluginAndArgOverridesAsync()
     {

dotnet/src/IntegrationTests/Agents/CommonInterfaceConformance/InvokeConformance/InvokeTests.cs

@@ -61,6 +61,25 @@ public virtual async Task InvokeWithoutThreadCreatesThreadAsync()
         await this.Fixture.DeleteThread(firstResult.Thread);
     }
 
+    [RetryFact(3, 5000)]
+    public virtual async Task InvokeWithoutMessageCreatesThreadAsync()
+    {
+        // Arrange
+        var agent = this.Fixture.Agent;
+
+        // Act
+        var asyncResults = agent.InvokeAsync([]);
+        var results = await asyncResults.ToListAsync();
+
+        // Assert
+        Assert.Single(results);
+        var firstResult = results.First();
+        Assert.NotNull(firstResult.Thread);
+
+        // Cleanup
+        await this.Fixture.DeleteThread(firstResult.Thread);
+    }
+
     [RetryFact(3, 5000)]
     public virtual async Task ConversationMaintainsHistoryAsync()
     {

dotnet/src/IntegrationTests/Agents/CommonInterfaceConformance/InvokeStreamingConformance/InvokeStreamingTests.cs

@@ -62,6 +62,25 @@ public virtual async Task InvokeStreamingAsyncWithoutThreadCreatesThreadAsync()
         await this.Fixture.DeleteThread(firstResult.Thread);
     }
 
+    [RetryFact(3, 10_000)]
+    public virtual async Task InvokeStreamingAsyncWithoutMessageCreatesThreadAsync()
+    {
+        // Arrange
+        var agent = this.Fixture.Agent;
+
+        // Act
+        var asyncResults = agent.InvokeStreamingAsync([]);
+        var results = await asyncResults.ToListAsync();
+
+        // Assert
+        var firstResult = results.First();
+        var resultString = string.Join(string.Empty, results.Select(x => x.Message.Content));
+        Assert.NotNull(firstResult.Thread);
+
+        // Cleanup
+        await this.Fixture.DeleteThread(firstResult.Thread);
+    }
+
     [RetryFact(3, 10_000)]
     public virtual async Task ConversationMaintainsHistoryAsync()
     {