Add .net support. Clean up TypeScript implementation

Author: SteveSandersonMS

dotnet/src/Session.cs

@@ -36,8 +36,8 @@ namespace GitHub.Copilot.SDK;
 ///     }
 /// });
 ///
-/// // Send a message
-/// await session.SendAsync(new MessageOptions { Prompt = "Hello, world!" });
+/// // Send a message and wait for completion
+/// await session.SendAndWaitAsync(new MessageOptions { Prompt = "Hello, world!" });
 /// </code>
 /// </example>
 public class CopilotSession : IAsyncDisposable
@@ -76,8 +76,13 @@ internal CopilotSession(string sessionId, JsonRpc rpc)
     /// <returns>A task that resolves with the ID of the response message, which can be used to correlate events.</returns>
     /// <exception cref="InvalidOperationException">Thrown if the session has been disposed.</exception>
     /// <remarks>
-    /// The message is processed asynchronously. Subscribe to events via <see cref="On"/> to receive
-    /// streaming responses and other session events.
+    /// <para>
+    /// This method returns immediately after the message is queued. Use <see cref="SendAndWaitAsync"/>
+    /// if you need to wait for the assistant to finish processing.
+    /// </para>
+    /// <para>
+    /// Subscribe to events via <see cref="On"/> to receive streaming responses and other session events.
+    /// </para>
     /// </remarks>
     /// <example>
     /// <code>
@@ -107,6 +112,65 @@ public async Task<string> SendAsync(MessageOptions options, CancellationToken ca
         return response.MessageId;
     }
 
+    /// <summary>
+    /// Sends a message to the Copilot session and waits until the session becomes idle.
+    /// </summary>
+    /// <param name="options">Options for the message to be sent, including the prompt and optional attachments.</param>
+    /// <param name="timeout">Timeout duration (default: 60 seconds). Controls how long to wait; does not abort in-flight agent work.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
+    /// <returns>A task that resolves with the final assistant message event, or null if none was received.</returns>
+    /// <exception cref="TimeoutException">Thrown if the timeout is reached before the session becomes idle.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if the session has been disposed.</exception>
+    /// <remarks>
+    /// <para>
+    /// This is a convenience method that combines <see cref="SendAsync"/> with waiting for
+    /// the <c>session.idle</c> event. Use this when you want to block until the assistant
+    /// has finished processing the message.
+    /// </para>
+    /// <para>
+    /// Events are still delivered to handlers registered via <see cref="On"/> while waiting.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// // Send and wait for completion with default 60s timeout
+    /// var response = await session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 2+2?" });
+    /// Console.WriteLine(response?.Data?.Content); // "4"
+    /// </code>
+    /// </example>
+    public async Task<AssistantMessageEvent?> SendAndWaitAsync(
+        MessageOptions options,
+        TimeSpan? timeout = null,
+        CancellationToken cancellationToken = default)
+    {
+        var effectiveTimeout = timeout ?? TimeSpan.FromSeconds(60);
+        var tcs = new TaskCompletionSource<AssistantMessageEvent?>();
+        AssistantMessageEvent? lastAssistantMessage = null;
+
+        void Handler(SessionEvent evt)
+        {
+            if (evt is AssistantMessageEvent assistantMessage)
+            {
+                lastAssistantMessage = assistantMessage;
+            }
+            else if (evt.Type == "session.idle")
+            {
+                tcs.TrySetResult(lastAssistantMessage);
+            }
+        }
+
+        using var subscription = On(Handler);
+
+        await SendAsync(options, cancellationToken);
+
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        cts.CancelAfter(effectiveTimeout);
+
+        using var registration = cts.Token.Register(() =>
+            tcs.TrySetException(new TimeoutException($"SendAndWaitAsync timed out after {effectiveTimeout}")));
+        return await tcs.Task;
+    }
+
     /// <summary>
     /// Registers a callback for session events.
     /// </summary>

dotnet/test/SessionTests.cs

@@ -322,4 +322,53 @@ public async Task Should_Receive_Session_Events()
 
         await session.DisposeAsync();
     }
+
+    [Fact]
+    public async Task Send_Returns_Immediately_While_Events_Stream_In_Background()
+    {
+        var session = await Client.CreateSessionAsync();
+        var events = new List<string>();
+
+        session.On(evt => events.Add(evt.Type));
+
+        await session.SendAsync(new MessageOptions { Prompt = "What is 1+1?" });
+
+        // send() should return before turn completes (no session.idle yet)
+        Assert.DoesNotContain("session.idle", events);
+
+        // Wait for turn to complete
+        var message = await TestHelper.GetFinalAssistantMessageAsync(session);
+
+        Assert.Contains("2", message?.Data.Content ?? string.Empty);
+        Assert.Contains("session.idle", events);
+        Assert.Contains("assistant.message", events);
+    }
+
+    [Fact]
+    public async Task SendAndWait_Blocks_Until_Session_Idle_And_Returns_Final_Assistant_Message()
+    {
+        var session = await Client.CreateSessionAsync();
+        var events = new List<string>();
+
+        session.On(evt => events.Add(evt.Type));
+
+        var response = await session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 2+2?" });
+
+        Assert.NotNull(response);
+        Assert.Equal("assistant.message", response!.Type);
+        Assert.Contains("4", response.Data.Content ?? string.Empty);
+        Assert.Contains("session.idle", events);
+        Assert.Contains("assistant.message", events);
+    }
+
+    [Fact]
+    public async Task SendAndWait_Throws_On_Timeout()
+    {
+        var session = await Client.CreateSessionAsync();
+
+        var ex = await Assert.ThrowsAsync<TimeoutException>(() =>
+            session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 3+3?" }, TimeSpan.FromMilliseconds(1)));
+
+        Assert.Contains("timed out", ex.Message);
+    }
 }

nodejs/src/session.ts

@@ -100,7 +100,7 @@ export class CopilotSession {
      * Events are still delivered to handlers registered via {@link on} while waiting.
      *
      * @param options - The message options including the prompt and optional attachments
-     * @param timeout - Timeout in milliseconds (default: 60000)
+     * @param timeout - Timeout in milliseconds (default: 60000). Controls how long to wait; does not abort in-flight agent work.
      * @returns A promise that resolves with the final assistant message when the session becomes idle,
      *          or undefined if no assistant message was received
      * @throws Error if the timeout is reached before the session becomes idle

nodejs/test/e2e/session.test.ts

@@ -384,4 +384,12 @@ describe("Send Blocking Behavior", async () => {
         expect(events).toContain("session.idle");
         expect(events).toContain("assistant.message");
     });
+
+    it("sendAndWait throws on timeout", async () => {
+        const session = await client.createSession();
+
+        await expect(session.sendAndWait({ prompt: "What is 3+3?" }, 1)).rejects.toThrow(
+            /Timeout after 1ms/
+        );
+    });
 });