Close Language Gaps for Commands + Dialogs/Elicitations (#960)

* Close Language Gaps for Commands + Dialogs/Elicitations

* Fix code quality review feedback and formatting issues

- Python: fix ruff formatting, add comments to empty except blocks, remove unused imports
- .NET: simplify boolean expressions, combine nested ifs, narrow generic catch clause
- Go: fix struct field alignment for go fmt compliance

* Fix Python ruff lint errors: unused imports, import sort order, line length

* Fix Python type checker errors: remove unused type-ignore comments, fix capabilities type

* Fix Go struct field alignment for go fmt compliance

* Fix Python E2E tests: use correct snapshot directory 'multi_client'

* Skip flaky Python E2E disconnect test: force_stop() doesn't trigger capabilities.changed reliably in replay proxy

* fix: close makefile wrapper in Python force_stop() to trigger TCP disconnect

Python's socket.makefile() holds its own reference to the socket.
Calling socket.close() alone won't release the OS-level resource
until the makefile wrapper is also closed. This meant force_stop()
wasn't actually closing the TCP connection, so the server never
detected the disconnect and never sent capabilities.changed events
to other clients.

Fix: close the file wrapper before the socket in SocketWrapper.terminate().
Unskip test_capabilities_changed_when_elicitation_provider_disconnects.

* fix: address remaining code review feedback

- Narrow generic catch clauses in .NET command/elicitation handlers
  with 'when (ex is not OperationCanceledException)' filter
- Remove redundant null-conditional (val?.ToString -> val.ToString)
  in SelectAsync and InputAsync switch expressions
- Add explanatory comments to Python empty except blocks

* fix: use socket.shutdown() in Python force_stop() for reliable disconnect

socket.close() and file wrapper close don't reliably interrupt a
blocking readline() on another thread in Python. socket.shutdown(SHUT_RDWR)
sends TCP FIN to the server immediately (triggering server-side
disconnect detection) and interrupts any pending blocking reads
across threads — matching Node.js socket.destroy() and Go conn.Close()
behavior.

* chore: remove working markdown files from PR

* fix: pass full elicitation schema in Go, add schema tests across SDKs

Go was only passing RequestedSchema.Properties to the elicitation
handler, dropping the 'type' and 'required' fields. This meant
handlers couldn't reconstruct the full JSON Schema. Now passes a
complete map with type, properties, and required.

Also replaces custom containsString/searchSubstring helpers in Go
tests with strings.Contains, and adds tests in Go and Python that
verify the full schema is passed through to elicitation handlers.

* fix: Go test compilation errors for schema extraction test

Use direct schema extraction logic test instead of dispatching
through session event machinery, avoiding need for RPC mocks.
Fixes undefined SessionEventData and handleEvent references.

* fix: resolve staticcheck SA4031 lint in Go schema test

* test: add Go command error, unknown command, and elicitation handler tests

- Command handler error propagation: verifies handler error is returned
- Unknown command: verifies getCommandHandler returns false for unknown
- Elicitation handler error: verifies error propagation from handler
- Elicitation handler success: verifies result with action and content

* fix: remove redundant nil check flagged by staticcheck SA4031

* docs: promote Commands and UI Elicitation to top-level sections in .NET README

Matches Go and Python README structure where these are ## (h2) sections
rather than ### (h3) subsections. Closes documentation gap flagged
by SDK Consistency Review Agent.

* fix: address human review feedback

.NET:
- Cache SessionUiApiImpl instance via Lazy<> instead of allocating on
  every .Ui access
- Await command/elicitation handler calls instead of redundant
  fire-and-forget (outer caller already fire-and-forgets)
- Use ElicitationRequestedDataMode enum for Mode instead of string

Go:
- Handle SessionEventTypeCapabilitiesChanged in handleBroadcastEvent
  to update session capabilities when other clients join/leave with
  elicitation handlers
- Add test verifying capabilities.changed event updates session

* refactor: merge ElicitationRequest + ElicitationInvocation into ElicitationContext

Combines the two-argument elicitation handler pattern into a single
ElicitationContext type across all three SDKs, matching the existing
CommandContext pattern. The context now includes SessionId alongside
the request fields (Message, RequestedSchema, Mode, etc.).

Changes per language:
- .NET: ElicitationContext class, single-arg delegate, Lazy<> cached Ui
- Go: ElicitationContext struct, single-arg handler func
- Python: ElicitationContext TypedDict, single-arg callable

All tests, READMEs, and E2E tests updated.

* refactor: apply ElicitationContext rename to Node.js SDK

Consistent with Python, Go, and .NET — ElicitationRequest is now
ElicitationContext with sessionId included. Handler takes single arg.
Completes the cross-SDK consistency change.

* style: fix formatting (prettier, ruff, trailing newlines)

* style: fix Python import sort order in __init__.py

* fix: simplify Ui auto-property and remove empty snapshot files

- Replace Lazy<ISessionUiApi> with simple auto-property initialized
  in constructor, per reviewer feedback
- Delete 14 empty snapshot YAML files (commands, elicitation,
  multi_client) that had no conversation data

* fix: rename misleading command test names

Renamed to accurately reflect what they verify:
- Forwards_Commands_In_Session_Create -> Session_With_Commands_Creates_Successfully
- Forwards_Commands_In_Session_Resume -> Session_With_Commands_Resumes_Successfully

Actual forwarding verification is in the multi-client test
Client_Receives_Commands_Changed_When_Another_Client_Joins_With_Commands
which proves the server received the commands by checking the
commands.changed event on another client.

* fix: remove leftover JSDoc from ElicitationRequest rename

Author: MRayermannMSFT

dotnet/README.md

@@ -488,6 +488,95 @@ var safeLookup = AIFunctionFactory.Create(
     });
 ```
 
+## Commands
+
+Register slash commands so that users of the CLI's TUI can invoke custom actions via `/commandName`. Each command has a `Name`, optional `Description`, and a `Handler` called when the user executes it.
+
+```csharp
+var session = await client.CreateSessionAsync(new SessionConfig
+{
+    Model = "gpt-5",
+    OnPermissionRequest = PermissionHandler.ApproveAll,
+    Commands =
+    [
+        new CommandDefinition
+        {
+            Name = "deploy",
+            Description = "Deploy the app to production",
+            Handler = async (context) =>
+            {
+                Console.WriteLine($"Deploying with args: {context.Args}");
+                // Do work here — any thrown error is reported back to the CLI
+            },
+        },
+    ],
+});
+```
+
+When the user types `/deploy staging` in the CLI, the SDK receives a `command.execute` event, routes it to your handler, and automatically responds to the CLI. If the handler throws, the error message is forwarded.
+
+Commands are sent to the CLI on both `CreateSessionAsync` and `ResumeSessionAsync`, so you can update the command set when resuming.
+
+## UI Elicitation
+
+When the session has elicitation support — either from the CLI's TUI or from another client that registered an `OnElicitationRequest` handler (see [Elicitation Requests](#elicitation-requests)) — the SDK can request interactive form dialogs from the user. The `session.Ui` object provides convenience methods built on a single generic elicitation RPC.
+
+> **Capability check:** Elicitation is only available when at least one connected participant advertises support. Always check `session.Capabilities.Ui?.Elicitation` before calling UI methods — this property updates automatically as participants join and leave.
+
+```csharp
+var session = await client.CreateSessionAsync(new SessionConfig
+{
+    Model = "gpt-5",
+    OnPermissionRequest = PermissionHandler.ApproveAll,
+});
+
+if (session.Capabilities.Ui?.Elicitation == true)
+{
+    // Confirm dialog — returns boolean
+    bool ok = await session.Ui.ConfirmAsync("Deploy to production?");
+
+    // Selection dialog — returns selected value or null
+    string? env = await session.Ui.SelectAsync("Pick environment",
+        ["production", "staging", "dev"]);
+
+    // Text input — returns string or null
+    string? name = await session.Ui.InputAsync("Project name:", new InputOptions
+    {
+        Title = "Name",
+        MinLength = 1,
+        MaxLength = 50,
+    });
+
+    // Generic elicitation with full schema control
+    ElicitationResult result = await session.Ui.ElicitationAsync(new ElicitationParams
+    {
+        Message = "Configure deployment",
+        RequestedSchema = new ElicitationSchema
+        {
+            Type = "object",
+            Properties = new Dictionary<string, object>
+            {
+                ["region"] = new Dictionary<string, object>
+                {
+                    ["type"] = "string",
+                    ["enum"] = new[] { "us-east", "eu-west" },
+                },
+                ["dryRun"] = new Dictionary<string, object>
+                {
+                    ["type"] = "boolean",
+                    ["default"] = true,
+                },
+            },
+            Required = ["region"],
+        },
+    });
+    // result.Action: Accept, Decline, or Cancel
+    // result.Content: { "region": "us-east", "dryRun": true } (when accepted)
+}
+```
+
+All UI methods throw if elicitation is not supported by the host.
+
 ### System Message Customization
 
 Control the system prompt using `SystemMessage` in session config:
@@ -812,6 +901,50 @@ var session = await client.CreateSessionAsync(new SessionConfig
 - `OnSessionEnd` - Cleanup or logging when session ends.
 - `OnErrorOccurred` - Handle errors with retry/skip/abort strategies.
 
+## Elicitation Requests
+
+Register an `OnElicitationRequest` handler to let your client act as an elicitation provider — presenting form-based UI dialogs on behalf of the agent. When provided, the server notifies your client whenever a tool or MCP server needs structured user input.
+
+```csharp
+var session = await client.CreateSessionAsync(new SessionConfig
+{
+    Model = "gpt-5",
+    OnPermissionRequest = PermissionHandler.ApproveAll,
+    OnElicitationRequest = async (context) =>
+    {
+        // context.SessionId - Session that triggered the request
+        // context.Message - Description of what information is needed
+        // context.RequestedSchema - JSON Schema describing the form fields
+        // context.Mode - "form" (structured input) or "url" (browser redirect)
+        // context.ElicitationSource - Origin of the request (e.g. MCP server name)
+
+        Console.WriteLine($"Elicitation from {context.ElicitationSource}: {context.Message}");
+
+        // Present UI to the user and collect their response...
+        return new ElicitationResult
+        {
+            Action = SessionUiElicitationResultAction.Accept,
+            Content = new Dictionary<string, object>
+            {
+                ["region"] = "us-east",
+                ["dryRun"] = true,
+            },
+        };
+    },
+});
+
+// The session now reports elicitation capability
+Console.WriteLine(session.Capabilities.Ui?.Elicitation); // True
+```
+
+When `OnElicitationRequest` is provided, the SDK sends `RequestElicitation = true` during session create/resume, which enables `session.Capabilities.Ui.Elicitation` on the session.
+
+In multi-client scenarios:
+
+- If no connected client was previously providing an elicitation capability, but a new client joins that can, all clients will receive a `capabilities.changed` event to notify them that elicitation is now possible. The SDK automatically updates `session.Capabilities` when these events arrive.
+- Similarly, if the last elicitation provider disconnects, all clients receive a `capabilities.changed` event indicating elicitation is no longer available.
+- The server fans out elicitation requests to **all** connected clients that registered a handler — the first response wins.
+
 ## Error Handling
 
 ```csharp

dotnet/src/Client.cs

@@ -456,6 +456,8 @@ public async Task<CopilotSession> CreateSessionAsync(SessionConfig config, Cance
         var session = new CopilotSession(sessionId, connection.Rpc, _logger);
         session.RegisterTools(config.Tools ?? []);
         session.RegisterPermissionHandler(config.OnPermissionRequest);
+        session.RegisterCommands(config.Commands);
+        session.RegisterElicitationHandler(config.OnElicitationRequest);
         if (config.OnUserInputRequest != null)
         {
             session.RegisterUserInputHandler(config.OnUserInputRequest);
@@ -501,13 +503,16 @@ public async Task<CopilotSession> CreateSessionAsync(SessionConfig config, Cance
                 config.SkillDirectories,
                 config.DisabledSkills,
                 config.InfiniteSessions,
-                traceparent,
-                tracestate);
+                Commands: config.Commands?.Select(c => new CommandWireDefinition(c.Name, c.Description)).ToList(),
+                RequestElicitation: config.OnElicitationRequest != null,
+                Traceparent: traceparent,
+                Tracestate: tracestate);
 
             var response = await InvokeRpcAsync<CreateSessionResponse>(
                 connection.Rpc, "session.create", [request], cancellationToken);
 
             session.WorkspacePath = response.WorkspacePath;
+            session.SetCapabilities(response.Capabilities);
         }
         catch
         {
@@ -570,6 +575,8 @@ public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSes
         var session = new CopilotSession(sessionId, connection.Rpc, _logger);
         session.RegisterTools(config.Tools ?? []);
         session.RegisterPermissionHandler(config.OnPermissionRequest);
+        session.RegisterCommands(config.Commands);
+        session.RegisterElicitationHandler(config.OnElicitationRequest);
         if (config.OnUserInputRequest != null)
         {
             session.RegisterUserInputHandler(config.OnUserInputRequest);
@@ -616,13 +623,16 @@ public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSes
                 config.SkillDirectories,
                 config.DisabledSkills,
                 config.InfiniteSessions,
-                traceparent,
-                tracestate);
+                Commands: config.Commands?.Select(c => new CommandWireDefinition(c.Name, c.Description)).ToList(),
+                RequestElicitation: config.OnElicitationRequest != null,
+                Traceparent: traceparent,
+                Tracestate: tracestate);
 
             var response = await InvokeRpcAsync<ResumeSessionResponse>(
                 connection.Rpc, "session.resume", [request], cancellationToken);
 
             session.WorkspacePath = response.WorkspacePath;
+            session.SetCapabilities(response.Capabilities);
         }
         catch
         {
@@ -1592,6 +1602,8 @@ internal record CreateSessionRequest(
         List<string>? SkillDirectories,
         List<string>? DisabledSkills,
         InfiniteSessionConfig? InfiniteSessions,
+        List<CommandWireDefinition>? Commands = null,
+        bool? RequestElicitation = null,
         string? Traceparent = null,
         string? Tracestate = null);
 
@@ -1614,7 +1626,8 @@ public static ToolDefinition FromAIFunction(AIFunction function)
 
     internal record CreateSessionResponse(
         string SessionId,
-        string? WorkspacePath);
+        string? WorkspacePath,
+        SessionCapabilities? Capabilities = null);
 
     internal record ResumeSessionRequest(
         string SessionId,
@@ -1640,12 +1653,19 @@ internal record ResumeSessionRequest(
         List<string>? SkillDirectories,
         List<string>? DisabledSkills,
         InfiniteSessionConfig? InfiniteSessions,
+        List<CommandWireDefinition>? Commands = null,
+        bool? RequestElicitation = null,
         string? Traceparent = null,
         string? Tracestate = null);
 
     internal record ResumeSessionResponse(
         string SessionId,
-        string? WorkspacePath);
+        string? WorkspacePath,
+        SessionCapabilities? Capabilities = null);
+
+    internal record CommandWireDefinition(
+        string Name,
+        string? Description);
 
     internal record GetLastSessionIdResponse(
         string? SessionId);
@@ -1782,9 +1802,12 @@ private static LogLevel MapLevel(TraceEventType eventType)
     [JsonSerializable(typeof(ProviderConfig))]
     [JsonSerializable(typeof(ResumeSessionRequest))]
     [JsonSerializable(typeof(ResumeSessionResponse))]
+    [JsonSerializable(typeof(SessionCapabilities))]
+    [JsonSerializable(typeof(SessionUiCapabilities))]
     [JsonSerializable(typeof(SessionMetadata))]
     [JsonSerializable(typeof(SystemMessageConfig))]
     [JsonSerializable(typeof(SystemMessageTransformRpcResponse))]
+    [JsonSerializable(typeof(CommandWireDefinition))]
     [JsonSerializable(typeof(ToolCallResponseV2))]
     [JsonSerializable(typeof(ToolDefinition))]
     [JsonSerializable(typeof(ToolResultAIContent))]