.Net: Add invoke overloads for string and no message. (#11219)

### Motivation and Context

Most invocations take a user message as input, so supporting just
passing the string is useful.
Some agents support invoking the agent without any message, so adding
explicit support for this is useful.

### Description

Add invoke overloads for string and no message.

### 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/samples/Demos/AgentFrameworkWithAspire/ChatWithAgent.ApiService/Controllers/AgentCompletionsController.cs

@@ -71,7 +71,7 @@ private async IAsyncEnumerable<ChatMessageContent> CompleteAsync(ChatHistory cha
     {
         var thread = new ChatHistoryAgentThread(chatHistory);
         IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> content =
-            this._agent.InvokeAsync([], thread, options: new() { KernelArguments = arguments }, cancellationToken: cancellationToken);
+            this._agent.InvokeAsync(thread, options: new() { KernelArguments = arguments }, cancellationToken: cancellationToken);
 
         await foreach (ChatMessageContent item in content.ConfigureAwait(false))
         {
@@ -90,7 +90,7 @@ private async IAsyncEnumerable<StreamingChatMessageContent> CompleteSteamingAsyn
     {
         var thread = new ChatHistoryAgentThread(chatHistory);
         IAsyncEnumerable<AgentResponseItem<StreamingChatMessageContent>> content =
-            this._agent.InvokeStreamingAsync([], thread, options: new() { KernelArguments = arguments }, cancellationToken: cancellationToken);
+            this._agent.InvokeStreamingAsync(thread, options: new() { KernelArguments = arguments }, cancellationToken: cancellationToken);
 
         await foreach (StreamingChatMessageContent item in content.ConfigureAwait(false))
         {

dotnet/samples/GettingStartedWithAgents/AzureAIAgent/Step01_AzureAIAgent.cs

@@ -58,7 +58,7 @@ await InvokeAgentAsync(
         // Local function to invoke agent and display the response.
         async Task InvokeAgentAsync(KernelArguments? arguments = null)
         {
-            await foreach (ChatMessageContent response in agent.InvokeAsync([], thread, new() { KernelArguments = arguments }))
+            await foreach (ChatMessageContent response in agent.InvokeAsync(thread, new() { KernelArguments = arguments }))
             {
                 WriteAgentChatMessage(response);
             }

dotnet/samples/GettingStartedWithAgents/OpenAIAssistant/Step01_Assistant.cs

@@ -58,7 +58,7 @@ await InvokeAgentAsync(
         // Local function to invoke agent and display the response.
         async Task InvokeAgentAsync(KernelArguments? arguments = null)
         {
-            await foreach (ChatMessageContent response in agent.InvokeAsync([], thread, options: new() { KernelArguments = arguments }))
+            await foreach (ChatMessageContent response in agent.InvokeAsync(thread, options: new() { KernelArguments = arguments }))
             {
                 WriteAgentChatMessage(response);
             }

dotnet/samples/GettingStartedWithAgents/Step01_Agent.cs

@@ -173,7 +173,7 @@ await InvokeAgentAsync(
         async Task InvokeAgentAsync(KernelArguments? arguments = null)
         {
             // Invoke the agent without any messages, since the agent has all that it needs via the template and arguments.
-            await foreach (ChatMessageContent content in agent.InvokeAsync([], options: new() { KernelArguments = arguments }))
+            await foreach (ChatMessageContent content in agent.InvokeAsync(options: new() { KernelArguments = arguments }))
             {
                 WriteAgentChatMessage(content);
             }

dotnet/src/Agents/Abstractions/Agent.cs

@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.SemanticKernel.ChatCompletion;
 
 namespace Microsoft.SemanticKernel.Agents;
 
@@ -43,6 +44,51 @@ public abstract class Agent
     /// </summary>
     public ILoggerFactory? LoggerFactory { get; init; }
 
+    /// <summary>
+    /// Invoke the agent with no message assuming that all required instructions are already provided to the agent or on the thread.
+    /// </summary>
+    /// <param name="thread">The conversation thread to continue with this invocation. If not provided, creates a new thread.</param>
+    /// <param name="options">Optional parameters for agent invocation.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>An async list of response items that each contain a <see cref="ChatMessageContent"/> and an <see cref="AgentThread"/>.</returns>
+    /// <remarks>
+    /// To continue this thread in the future, use an <see cref="AgentThread"/> returned in one of the response items.
+    /// </remarks>
+    public virtual IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> InvokeAsync(
+        AgentThread? thread = null,
+        AgentInvokeOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return this.InvokeAsync([], thread, options, cancellationToken);
+    }
+
+    /// <summary>
+    /// Invoke the agent with the provided message and arguments.
+    /// </summary>
+    /// <param name="message">The message to pass to the agent.</param>
+    /// <param name="thread">The conversation thread to continue with this invocation. If not provided, creates a new thread.</param>
+    /// <param name="options">Optional parameters for agent invocation.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>An async list of response items that each contain a <see cref="ChatMessageContent"/> and an <see cref="AgentThread"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// The provided message string will be treated as a user message.
+    /// </para>
+    /// <para>
+    /// To continue this thread in the future, use an <see cref="AgentThread"/> returned in one of the response items.
+    /// </para>
+    /// </remarks>
+    public virtual IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> InvokeAsync(
+        string message,
+        AgentThread? thread = null,
+        AgentInvokeOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        Verify.NotNull(message);
+
+        return this.InvokeAsync(new ChatMessageContent(AuthorRole.User, message), thread, options, cancellationToken);
+    }
+
     /// <summary>
     /// Invoke the agent with the provided message and arguments.
     /// </summary>
@@ -60,7 +106,9 @@ public virtual IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> InvokeAsy
         AgentInvokeOptions? options = null,
         CancellationToken cancellationToken = default)
     {
-        return this.InvokeAsync(new[] { message }, thread, options, cancellationToken);
+        Verify.NotNull(message);
+
+        return this.InvokeAsync([message], thread, options, cancellationToken);
     }
 
     /// <summary>
@@ -80,6 +128,51 @@ public abstract IAsyncEnumerable<AgentResponseItem<ChatMessageContent>> InvokeAs
         AgentInvokeOptions? options = null,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Invoke the agent with no message assuming that all required instructions are already provided to the agent or on the thread.
+    /// </summary>
+    /// <param name="thread">The conversation thread to continue with this invocation. If not provided, creates a new thread.</param>
+    /// <param name="options">Optional parameters for agent invocation.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>An async list of response items that each contain a <see cref="ChatMessageContent"/> and an <see cref="AgentThread"/>.</returns>
+    /// <remarks>
+    /// To continue this thread in the future, use an <see cref="AgentThread"/> returned in one of the response items.
+    /// </remarks>
+    public virtual IAsyncEnumerable<AgentResponseItem<StreamingChatMessageContent>> InvokeStreamingAsync(
+        AgentThread? thread = null,
+        AgentInvokeOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return this.InvokeStreamingAsync([], thread, options, cancellationToken);
+    }
+
+    /// <summary>
+    /// Invoke the agent with the provided message and arguments.
+    /// </summary>
+    /// <param name="message">The message to pass to the agent.</param>
+    /// <param name="thread">The conversation thread to continue with this invocation. If not provided, creates a new thread.</param>
+    /// <param name="options">Optional parameters for agent invocation.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>An async list of response items that each contain a <see cref="ChatMessageContent"/> and an <see cref="AgentThread"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// The provided message string will be treated as a user message.
+    /// </para>
+    /// <para>
+    /// To continue this thread in the future, use an <see cref="AgentThread"/> returned in one of the response items.
+    /// </para>
+    /// </remarks>
+    public virtual IAsyncEnumerable<AgentResponseItem<StreamingChatMessageContent>> InvokeStreamingAsync(
+        string message,
+        AgentThread? thread = null,
+        AgentInvokeOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        Verify.NotNull(message);
+
+        return this.InvokeStreamingAsync(new ChatMessageContent(AuthorRole.User, message), thread, options, cancellationToken);
+    }
+
     /// <summary>
     /// Invoke the agent with the provided message and arguments.
     /// </summary>
@@ -97,7 +190,9 @@ public virtual IAsyncEnumerable<AgentResponseItem<StreamingChatMessageContent>>
         AgentInvokeOptions? options = null,
         CancellationToken cancellationToken = default)
     {
-        return this.InvokeStreamingAsync(new[] { message }, thread, options, cancellationToken);
+        Verify.NotNull(message);
+
+        return this.InvokeStreamingAsync([message], thread, options, cancellationToken);
     }
 
     /// <summary>