Client.cs

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *--------------------------------------------------------------------------------------------*/

using GitHub.Copilot.SDK.Rpc;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Globalization;
using System.Net.Sockets;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;

namespace GitHub.Copilot.SDK;

/// <summary>
/// Provides a client for interacting with the Copilot CLI server.
/// </summary>
/// <remarks>
/// <para>
/// The <see cref="CopilotClient"/> manages the connection to the Copilot CLI server and provides
/// methods to create and manage conversation sessions. It can either spawn a CLI server process
/// or connect to an existing server.
/// </para>
/// <para>
/// The client supports both stdio (default) and TCP transport modes for communication with the CLI server.
/// </para>
/// </remarks>
/// <example>
/// <code>
/// // Create a client with default options (spawns CLI server)
/// await using var client = new CopilotClient();
///
/// // Create a session
/// await using var session = await client.CreateSessionAsync(new() { OnPermissionRequest = PermissionHandler.ApproveAll, Model = "gpt-4" });
///
/// // Handle events
/// using var subscription = session.On(evt =>
/// {
///     if (evt is AssistantMessageEvent assistantMessage)
///         Console.WriteLine(assistantMessage.Data?.Content);
/// });
///
/// // Send a message
/// await session.SendAsync(new MessageOptions { Prompt = "Hello!" });
/// </code>
/// </example>
public sealed partial class CopilotClient : IDisposable, IAsyncDisposable
{
    internal const string NoResultPermissionV2ErrorMessage =
        "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";

    /// <summary>
    /// Minimum protocol version this SDK can communicate with.
    /// </summary>
    private const int MinProtocolVersion = 2;

    /// <summary>
    /// Provides a thread-safe collection of active Copilot sessions, indexed by session identifier.
    /// </summary>
    /// <remarks>
    /// This maintains a strong reference to every <see cref="CopilotSession"/> created on this
    /// <see cref="CopilotClient"/> that has not been explicitly disposed or removed.
    /// </remarks>
    internal readonly ConcurrentDictionary<string, CopilotSession> _sessions = new();

    private readonly CopilotClientOptions _options;
    private readonly ILogger _logger;
    private Task<Connection>? _connectionTask;
    private volatile bool _disconnected;
    private bool _disposed;
    private readonly int? _optionsPort;
    private readonly string? _optionsHost;
    private readonly string? _effectiveConnectionToken;
    private int? _actualPort;
    private int? _negotiatedProtocolVersion;
    private List<ModelInfo>? _modelsCache;
    private readonly SemaphoreSlim _modelsCacheLock = new(1, 1);
    private readonly Func<CancellationToken, Task<IList<ModelInfo>>>? _onListModels;
    private readonly List<Action<SessionLifecycleEvent>> _lifecycleHandlers = [];
    private readonly Dictionary<string, List<Action<SessionLifecycleEvent>>> _typedLifecycleHandlers = [];
    private readonly object _lifecycleHandlersLock = new();
    private ServerRpc? _serverRpc;

    /// <summary>
    /// Gets the typed RPC client for server-scoped methods (no session required).
    /// </summary>
    /// <remarks>
    /// The client must be started before accessing this property. Use <see cref="StartAsync"/> or set <see cref="CopilotClientOptions.AutoStart"/> to true.
    /// </remarks>
    /// <exception cref="ObjectDisposedException">Thrown if the client has been disposed.</exception>
    /// <exception cref="InvalidOperationException">Thrown if the client is not started.</exception>
    public ServerRpc Rpc => _disposed
        ? throw new ObjectDisposedException(nameof(CopilotClient))
        : _serverRpc ?? throw new InvalidOperationException("Client is not started. Call StartAsync first.");

    /// <summary>
    /// Gets the actual TCP port the CLI server is listening on, if using TCP transport.
    /// </summary>
    public int? ActualPort => _actualPort;

    /// <summary>
    /// Creates a new instance of <see cref="CopilotClient"/>.
    /// </summary>
    /// <param name="options">Options for creating the client. If null, default options are used.</param>
    /// <exception cref="ArgumentException">Thrown when mutually exclusive options are provided (e.g., CliUrl with UseStdio or CliPath).</exception>
    /// <example>
    /// <code>
    /// // Default options - spawns CLI server using stdio
    /// var client = new CopilotClient();
    ///
    /// // Connect to an existing server
    /// var client = new CopilotClient(new CopilotClientOptions { CliUrl = "localhost:3000", UseStdio = false });
    ///
    /// // Custom CLI path with specific log level
    /// var client = new CopilotClient(new CopilotClientOptions
    /// {
    ///     CliPath = "/usr/local/bin/copilot",
    ///     LogLevel = "debug"
    /// });
    /// </code>
    /// </example>
    public CopilotClient(CopilotClientOptions? options = null)
    {
        _options = options ?? new();

        // Validate mutually exclusive options
        if (!string.IsNullOrEmpty(_options.CliUrl) && (_options.UseStdio == true || _options.CliPath != null))
        {
            throw new ArgumentException("CliUrl is mutually exclusive with UseStdio and CliPath");
        }

        // When CliUrl is provided, force TCP mode (we connect to an external server, not spawn one)
        if (!string.IsNullOrEmpty(_options.CliUrl))
        {
            _options.UseStdio = false;
        }
        else
        {
            _options.UseStdio ??= true;
        }

        // Validate auth options with external server
        if (!string.IsNullOrEmpty(_options.CliUrl) && (!string.IsNullOrEmpty(_options.GitHubToken) || _options.UseLoggedInUser != null))
        {
            throw new ArgumentException("GitHubToken and UseLoggedInUser cannot be used with CliUrl (external server manages its own auth)");
        }

        if (_options.TcpConnectionToken is not null)
        {
            if (_options.TcpConnectionToken.Length == 0)
            {
                throw new ArgumentException("TcpConnectionToken must be a non-empty string");
            }
            if (_options.UseStdio == true)
            {
                throw new ArgumentException("TcpConnectionToken cannot be used with UseStdio = true");
            }
        }

        var sdkSpawnsCli = _options.UseStdio == false && string.IsNullOrEmpty(_options.CliUrl);
        _effectiveConnectionToken = _options.TcpConnectionToken
            ?? (sdkSpawnsCli ? Guid.NewGuid().ToString() : null);

        _logger = _options.Logger ?? NullLogger.Instance;
        _onListModels = _options.OnListModels;

        // Parse CliUrl if provided
        if (!string.IsNullOrEmpty(_options.CliUrl))
        {
            var uri = ParseCliUrl(_options.CliUrl!);
            _optionsHost = uri.Host;
            _optionsPort = uri.Port;
        }
    }

    /// <summary>
    /// Parses a CLI URL into a URI with host and port.
    /// </summary>
    /// <param name="url">The URL to parse. Supports formats: "port", "host:port", "http://host:port".</param>
    /// <returns>A <see cref="Uri"/> containing the parsed host and port.</returns>
    private static Uri ParseCliUrl(string url)
    {
        // If it's just a port number, treat as localhost
        if (int.TryParse(url, out var port))
        {
            return new Uri($"http://localhost:{port}");
        }

        // Add scheme if missing
        if (!url.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
            !url.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
        {
            url = "https://" + url;
        }

        return new Uri(url);
    }

    /// <summary>
    /// Starts the Copilot client and connects to the server.
    /// </summary>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
    /// <remarks>
    /// <para>
    /// If the server is not already running and the client is configured to spawn one (default), it will be started.
    /// If connecting to an external server (via CliUrl), only establishes the connection.
    /// </para>
    /// <para>
    /// This method is called automatically when creating a session if <see cref="CopilotClientOptions.AutoStart"/> is true (default).
    /// </para>
    /// </remarks>
    /// <example>
    /// <code>
    /// var client = new CopilotClient(new CopilotClientOptions { AutoStart = false });
    /// await client.StartAsync();
    /// // Now ready to create sessions
    /// </code>
    /// </example>
    public Task StartAsync(CancellationToken cancellationToken = default)
    {
        return _connectionTask ??= StartCoreAsync(cancellationToken);

        async Task<Connection> StartCoreAsync(CancellationToken ct)
        {
            _logger.LogDebug("Starting Copilot client");
            _disconnected = false;

            var startTimestamp = Stopwatch.GetTimestamp();
            Connection? connection = null;
            Process? cliProcess = null;

            try
            {
                if (_optionsHost is not null && _optionsPort is not null)
                {
                    // External server (TCP)
                    _actualPort = _optionsPort;
                    connection = await ConnectToServerAsync(null, _optionsHost, _optionsPort, null, ct);
                }
                else
                {
                    // Child process (stdio or TCP)
                    var (startedProcess, portOrNull, stderrBuffer) = await StartCliServerAsync(_options, _effectiveConnectionToken, _logger, ct);
                    cliProcess = startedProcess;
                    _actualPort = portOrNull;
                    connection = await ConnectToServerAsync(cliProcess, portOrNull is null ? null : "localhost", portOrNull, stderrBuffer, ct);
                }

                LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
                    "CopilotClient.StartAsync transport setup complete. Elapsed={Elapsed}",
                    startTimestamp);

                // Verify protocol version compatibility
                await VerifyProtocolVersionAsync(connection, ct);
                LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
                    "CopilotClient.StartAsync protocol verification complete. Elapsed={Elapsed}",
                    startTimestamp);

                var sessionFsTimestamp = Stopwatch.GetTimestamp();
                await ConfigureSessionFsAsync(ct);
                if (_options.SessionFs is not null)
                {
                    LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
                        "CopilotClient.StartAsync session filesystem setup complete. Elapsed={Elapsed}",
                        sessionFsTimestamp);
                }

                LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
                    "CopilotClient.StartAsync complete. Elapsed={Elapsed}",
                    startTimestamp);
                return connection;
            }
            catch (Exception ex)
            {
                if (ex is not OperationCanceledException)
                {
                    LoggingHelpers.LogTiming(_logger, LogLevel.Warning, ex,
                        "CopilotClient.StartAsync failed. Elapsed={Elapsed}",
                        startTimestamp);
                }

                if (connection is not null)
                {
                    await CleanupConnectionAsync(connection, errors: null);
                }
                else if (cliProcess is not null)
                {
                    await CleanupCliProcessAsync(cliProcess, errors: null, _logger);
                }

                throw;
            }
        }
    }

    /// <summary>
    /// Disconnects from the Copilot server and closes all active sessions.
    /// </summary>
    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
    /// <remarks>
    /// <para>
    /// This method performs graceful cleanup:
    /// <list type="number">
    ///     <item>Closes all active sessions (releases in-memory resources)</item>
    ///     <item>Closes the JSON-RPC connection</item>
    ///     <item>Terminates the CLI server process (if spawned by this client)</item>
    /// </list>
    /// </para>
    /// <para>
    /// Note: session data on disk is preserved, so sessions can be resumed later.
    /// To permanently remove session data before stopping, call
    /// <see cref="DeleteSessionAsync"/> for each session first.
    /// </para>
    /// </remarks>
    /// <exception cref="AggregateException">Thrown when multiple errors occur during cleanup.</exception>
    /// <example>
    /// <code>
    /// await client.StopAsync();
    /// </code>
    /// </example>
    public async Task StopAsync()
    {
        List<Exception> errors = [];

        foreach (var session in _sessions.Values.ToArray())
        {
            try
            {
                await session.DisposeAsync();
            }
            catch (Exception ex)
            {
                errors.Add(new IOException($"Failed to dispose session {session.SessionId}: {ex.Message}", ex));
            }
        }

        _sessions.Clear();

        await CleanupConnectionAsync(errors);

        ThrowErrors(errors);
    }

    /// <summary>
    /// Forces an immediate stop of the client without graceful cleanup.
    /// </summary>
    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
    /// <remarks>
    /// Use this when <see cref="StopAsync"/> fails or takes too long. This method:
    /// <list type="bullet">
    ///     <item>Clears all sessions immediately without destroying them</item>
    ///     <item>Force closes the connection</item>
    ///     <item>Kills the CLI process (if spawned by this client)</item>
    /// </list>
    /// </remarks>
    /// <example>
    /// <code>
    /// // If normal stop hangs, force stop
    /// var stopTask = client.StopAsync();
    /// if (!stopTask.Wait(TimeSpan.FromSeconds(5)))
    /// {
    ///     await client.ForceStopAsync();
    /// }
    /// </code>
    /// </example>
    public async Task ForceStopAsync()
    {
        _sessions.Clear();

        var errors = new List<Exception>();
        await CleanupConnectionAsync(errors);
        ThrowErrors(errors);
    }

    private static void ThrowErrors(List<Exception>? errors)
    {
        if (errors is not null)
        {
            if (errors.Count == 1)
            {
                ExceptionDispatchInfo.Throw(errors[0]);
            }

            if (errors.Count > 0)
            {
                throw new AggregateException(errors);
            }
        }
    }

    private async Task CleanupConnectionAsync(List<Exception>? errors)
    {
        var connectionTask = _connectionTask;
        if (connectionTask is null)
        {
            return;
        }

        _connectionTask = null;

        Connection ctx;
        try
        {
            ctx = await connectionTask;
        }
        catch (Exception ex)
        {
            _logger.LogDebug(ex, "Ignoring failed Copilot client startup during cleanup");
            return;
        }

        await CleanupConnectionAsync(ctx, errors);
    }

    private async Task CleanupConnectionAsync(Connection ctx, List<Exception>? errors)
    {
        try { ctx.Rpc.Dispose(); }
        catch (Exception ex) { AddCleanupError(errors, ex, _logger); }

        // Clear RPC and models cache
        _serverRpc = null;
        _modelsCache = null;

        if (ctx.NetworkStream is not null)
        {
            try { await ctx.NetworkStream.DisposeAsync(); }
            catch (Exception ex) { AddCleanupError(errors, ex, _logger); }
        }

        if (ctx.CliProcess is { } childProcess)
        {
            await CleanupCliProcessAsync(childProcess, errors, _logger);
        }
    }

    private static async Task CleanupCliProcessAsync(Process childProcess, List<Exception>? errors, ILogger? logger)
    {
        try
        {
            try
            {
                if (!childProcess.HasExited)
                {
                    childProcess.Kill(entireProcessTree: true);
                    await childProcess.WaitForExitAsync();
                }
            }
            finally
            {
                childProcess.Dispose();
            }
        }
        catch (Exception ex)
        {
            AddCleanupError(errors, ex, logger);
        }
    }

    private static void AddCleanupError(List<Exception>? errors, Exception ex, ILogger? logger)
    {
        if (errors is not null)
        {
            errors.Add(ex);
        }
        else
        {
            logger?.LogDebug(ex, "Error while cleaning up Copilot CLI connection");
        }
    }

    private static (SystemMessageConfig? wireConfig, Dictionary<string, Func<string, Task<string>>>? callbacks) ExtractTransformCallbacks(SystemMessageConfig? systemMessage)
    {
        if (systemMessage?.Mode != SystemMessageMode.Customize || systemMessage.Sections == null)
        {
            return (systemMessage, null);
        }

        var callbacks = new Dictionary<string, Func<string, Task<string>>>();
        var wireSections = new Dictionary<string, SectionOverride>();

        foreach (var (sectionId, sectionOverride) in systemMessage.Sections)
        {
            if (sectionOverride.Transform != null)
            {
                callbacks[sectionId] = sectionOverride.Transform;
                wireSections[sectionId] = new SectionOverride { Action = SectionOverrideAction.Transform };
            }
            else
            {
                wireSections[sectionId] = sectionOverride;
            }
        }

        if (callbacks.Count == 0)
        {
            return (systemMessage, null);
        }

        var wireConfig = new SystemMessageConfig
        {
            Mode = systemMessage.Mode,
            Content = systemMessage.Content,
            Sections = wireSections
        };

        return (wireConfig, callbacks);
    }

    /// <summary>
    /// Creates a new Copilot session with the specified configuration.
    /// </summary>
    /// <param name="config">Configuration for the session.</param>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves to provide the <see cref="CopilotSession"/>.</returns>
    /// <remarks>
    /// Sessions maintain conversation state, handle events, and manage tool execution.
    /// If the client is not connected and <see cref="CopilotClientOptions.AutoStart"/> is enabled (default),
    /// this will automatically start the connection.
    /// </remarks>
    /// <example>
    /// <code>
    /// // Basic session
    /// var session = await client.CreateSessionAsync(new() { OnPermissionRequest = PermissionHandler.ApproveAll });
    ///
    /// // Session with model and tools
    /// var session = await client.CreateSessionAsync(new()
    /// {
    ///     OnPermissionRequest = PermissionHandler.ApproveAll,
    ///     Model = "gpt-4",
    ///     Tools = [AIFunctionFactory.Create(MyToolMethod)]
    /// });
    /// </code>
    /// </example>
    public async Task<CopilotSession> CreateSessionAsync(SessionConfig config, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(config);

        var connection = await EnsureConnectedAsync(cancellationToken);
        var totalTimestamp = Stopwatch.GetTimestamp();

        var hasHooks = config.Hooks != null && (
            config.Hooks.OnPreToolUse != null ||
            config.Hooks.OnPostToolUse != null ||
            config.Hooks.OnUserPromptSubmitted != null ||
            config.Hooks.OnSessionStart != null ||
            config.Hooks.OnSessionEnd != null ||
            config.Hooks.OnErrorOccurred != null);

        var (wireSystemMessage, transformCallbacks) = ExtractTransformCallbacks(config.SystemMessage);

        var sessionId = config.SessionId ?? Guid.NewGuid().ToString();

        // Create and register the session before issuing the RPC so that
        // events emitted by the CLI (e.g. session.start) are not dropped.
        var setupTimestamp = Stopwatch.GetTimestamp();
        var session = new CopilotSession(
            sessionId,
            connection.Rpc,
            _logger,
            this);
        session.RegisterTools(config.Tools ?? []);
        session.RegisterPermissionHandler(config.OnPermissionRequest);
        session.RegisterCommands(config.Commands);
        session.RegisterElicitationHandler(config.OnElicitationRequest);
        session.RegisterExitPlanModeHandler(config.OnExitPlanMode);
        session.RegisterAutoModeSwitchHandler(config.OnAutoModeSwitch);
        if (config.OnUserInputRequest != null)
        {
            session.RegisterUserInputHandler(config.OnUserInputRequest);
        }
        if (config.Hooks != null)
        {
            session.RegisterHooks(config.Hooks);
        }
        if (transformCallbacks != null)
        {
            session.RegisterTransformCallbacks(transformCallbacks);
        }
        if (config.OnEvent != null)
        {
            session.On(config.OnEvent);
        }
        ConfigureSessionFsHandlers(session, config.CreateSessionFsHandler);
        RegisterSession(session);
        session.StartProcessingEvents();
        LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
            "CopilotClient.CreateSessionAsync local setup complete. Elapsed={Elapsed}, SessionId={SessionId}, Tools={ToolsCount}, Commands={CommandsCount}, Hooks={HasHooks}",
            setupTimestamp,
            sessionId,
            config.Tools?.Count ?? 0,
            config.Commands?.Count ?? 0,
            hasHooks);

        try
        {
            var (traceparent, tracestate) = TelemetryHelpers.GetTraceContext();

            var request = new CreateSessionRequest(
                config.Model,
                sessionId,
                config.ClientName,
                config.ReasoningEffort,
                config.Tools?.Select(ToolDefinition.FromAIFunction).ToList(),
                wireSystemMessage,
                config.AvailableTools,
                config.ExcludedTools,
                config.Provider,
                config.EnableSessionTelemetry,
                (bool?)true,
                config.OnUserInputRequest != null ? true : null,
                config.OnExitPlanMode != null ? true : null,
                config.OnAutoModeSwitch != null ? true : null,
                hasHooks ? true : null,
                config.WorkingDirectory,
                config.Streaming is true ? true : null,
                config.IncludeSubAgentStreamingEvents,
                config.McpServers,
                "direct",
                config.CustomAgents,
                config.DefaultAgent,
                config.Agent,
                config.ConfigDir,
                config.EnableConfigDiscovery,
                config.SkillDirectories,
                config.DisabledSkills,
                config.InfiniteSessions,
                Commands: config.Commands?.Select(c => new CommandWireDefinition(c.Name, c.Description)).ToList(),
                RequestElicitation: config.OnElicitationRequest != null,
                Traceparent: traceparent,
                Tracestate: tracestate,
                ModelCapabilities: config.ModelCapabilities,
                GitHubToken: config.GitHubToken,
                RemoteSession: config.RemoteSession,
                Cloud: config.Cloud,
                InstructionDirectories: config.InstructionDirectories);

            var rpcTimestamp = Stopwatch.GetTimestamp();
            var response = await InvokeRpcAsync<CreateSessionResponse>(
                connection.Rpc, "session.create", [request], cancellationToken);
            LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
                "CopilotClient.CreateSessionAsync session creation request completed successfully. Elapsed={Elapsed}, SessionId={SessionId}",
                rpcTimestamp,
                sessionId);

            session.WorkspacePath = response.WorkspacePath;
            session.SetCapabilities(response.Capabilities);
        }
        catch (Exception ex)
        {
            session.RemoveFromClient();
            if (ex is not OperationCanceledException)
            {
                LoggingHelpers.LogTiming(_logger, LogLevel.Warning, ex,
                    "CopilotClient.CreateSessionAsync failed. Elapsed={Elapsed}, SessionId={SessionId}",
                    totalTimestamp,
                    sessionId);
            }
            throw;
        }

        LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
            "CopilotClient.CreateSessionAsync complete. Elapsed={Elapsed}, SessionId={SessionId}",
            totalTimestamp,
            sessionId);
        return session;
    }

    /// <summary>
    /// Resumes an existing Copilot session with the specified configuration.
    /// </summary>
    /// <param name="sessionId">The ID of the session to resume.</param>
    /// <param name="config">Configuration for the resumed session.</param>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves to provide the <see cref="CopilotSession"/>.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the session does not exist or the client is not connected.</exception>
    /// <remarks>
    /// This allows you to continue a previous conversation, maintaining all conversation history.
    /// The session must have been previously created and not deleted.
    /// </remarks>
    /// <example>
    /// <code>
    /// // Resume a previous session
    /// var session = await client.ResumeSessionAsync("session-123", new() { OnPermissionRequest = PermissionHandler.ApproveAll });
    ///
    /// // Resume with new tools
    /// var session = await client.ResumeSessionAsync("session-123", new()
    /// {
    ///     OnPermissionRequest = PermissionHandler.ApproveAll,
    ///     Tools = [AIFunctionFactory.Create(MyNewToolMethod)]
    /// });
    /// </code>
    /// </example>
    public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSessionConfig config, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);
        ArgumentNullException.ThrowIfNull(config);

        var connection = await EnsureConnectedAsync(cancellationToken);
        var totalTimestamp = Stopwatch.GetTimestamp();

        var hasHooks = config.Hooks != null && (
            config.Hooks.OnPreToolUse != null ||
            config.Hooks.OnPostToolUse != null ||
            config.Hooks.OnUserPromptSubmitted != null ||
            config.Hooks.OnSessionStart != null ||
            config.Hooks.OnSessionEnd != null ||
            config.Hooks.OnErrorOccurred != null);

        var (wireSystemMessage, transformCallbacks) = ExtractTransformCallbacks(config.SystemMessage);

        // Create and register the session before issuing the RPC so that
        // events emitted by the CLI (e.g. session.start) are not dropped.
        var setupTimestamp = Stopwatch.GetTimestamp();
        var session = new CopilotSession(
            sessionId,
            connection.Rpc,
            _logger,
            client: this);
        session.RegisterTools(config.Tools ?? []);
        session.RegisterPermissionHandler(config.OnPermissionRequest);
        session.RegisterCommands(config.Commands);
        session.RegisterElicitationHandler(config.OnElicitationRequest);
        session.RegisterExitPlanModeHandler(config.OnExitPlanMode);
        session.RegisterAutoModeSwitchHandler(config.OnAutoModeSwitch);
        if (config.OnUserInputRequest != null)
        {
            session.RegisterUserInputHandler(config.OnUserInputRequest);
        }
        if (config.Hooks != null)
        {
            session.RegisterHooks(config.Hooks);
        }
        if (transformCallbacks != null)
        {
            session.RegisterTransformCallbacks(transformCallbacks);
        }
        if (config.OnEvent != null)
        {
            session.On(config.OnEvent);
        }
        ConfigureSessionFsHandlers(session, config.CreateSessionFsHandler);
        RegisterSession(session);
        session.StartProcessingEvents();
        LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
            "CopilotClient.ResumeSessionAsync local setup complete. Elapsed={Elapsed}, SessionId={SessionId}, Tools={ToolsCount}, Commands={CommandsCount}, Hooks={HasHooks}",
            setupTimestamp,
            sessionId,
            config.Tools?.Count ?? 0,
            config.Commands?.Count ?? 0,
            hasHooks);

        try
        {
            var (traceparent, tracestate) = TelemetryHelpers.GetTraceContext();

            var request = new ResumeSessionRequest(
                sessionId,
                config.ClientName,
                config.Model,
                config.ReasoningEffort,
                config.Tools?.Select(ToolDefinition.FromAIFunction).ToList(),
                wireSystemMessage,
                config.AvailableTools,
                config.ExcludedTools,
                config.Provider,
                config.EnableSessionTelemetry,
                (bool?)true,
                config.OnUserInputRequest != null ? true : null,
                config.OnExitPlanMode != null ? true : null,
                config.OnAutoModeSwitch != null ? true : null,
                hasHooks ? true : null,
                config.WorkingDirectory,
                config.ConfigDir,
                config.EnableConfigDiscovery,
                config.DisableResume is true ? true : null,
                config.Streaming is true ? true : null,
                config.IncludeSubAgentStreamingEvents,
                config.McpServers,
                "direct",
                config.CustomAgents,
                config.DefaultAgent,
                config.Agent,
                config.SkillDirectories,
                config.DisabledSkills,
                config.InfiniteSessions,
                Commands: config.Commands?.Select(c => new CommandWireDefinition(c.Name, c.Description)).ToList(),
                RequestElicitation: config.OnElicitationRequest != null,
                Traceparent: traceparent,
                Tracestate: tracestate,
                ModelCapabilities: config.ModelCapabilities,
                GitHubToken: config.GitHubToken,
                RemoteSession: config.RemoteSession,
                ContinuePendingWork: config.ContinuePendingWork,
                InstructionDirectories: config.InstructionDirectories);

            var rpcTimestamp = Stopwatch.GetTimestamp();
            var response = await InvokeRpcAsync<ResumeSessionResponse>(
                connection.Rpc, "session.resume", [request], cancellationToken);
            LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
                "CopilotClient.ResumeSessionAsync session resume request completed successfully. Elapsed={Elapsed}, SessionId={SessionId}",
                rpcTimestamp,
                sessionId);

            session.WorkspacePath = response.WorkspacePath;
            session.SetCapabilities(response.Capabilities);
        }
        catch (Exception ex)
        {
            session.RemoveFromClient();
            if (ex is not OperationCanceledException)
            {
                LoggingHelpers.LogTiming(_logger, LogLevel.Warning, ex,
                    "CopilotClient.ResumeSessionAsync failed. Elapsed={Elapsed}, SessionId={SessionId}",
                    totalTimestamp,
                    sessionId);
            }
            throw;
        }

        LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
            "CopilotClient.ResumeSessionAsync complete. Elapsed={Elapsed}, SessionId={SessionId}",
            totalTimestamp,
            sessionId);
        return session;
    }

    /// <summary>
    /// Gets the current connection state of the client.
    /// </summary>
    /// <value>
    /// The current <see cref="ConnectionState"/>: Disconnected, Connecting, Connected, or Error.
    /// </value>
    /// <example>
    /// <code>
    /// if (client.State == ConnectionState.Connected)
    /// {
    ///     var session = await client.CreateSessionAsync(new() { OnPermissionRequest = PermissionHandler.ApproveAll });
    /// }
    /// </code>
    /// </example>
    public ConnectionState State
    {
        get
        {
            if (_connectionTask == null) return ConnectionState.Disconnected;
            if (_connectionTask.IsFaulted) return ConnectionState.Error;
            if (!_connectionTask.IsCompleted) return ConnectionState.Connecting;
            if (_disconnected) return ConnectionState.Disconnected;
            return ConnectionState.Connected;
        }
    }

    /// <summary>
    /// Validates the health of the connection by sending a ping request.
    /// </summary>
    /// <param name="message">An optional message that will be reflected back in the response.</param>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves with the <see cref="PingResponse"/> containing the message and server timestamp.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the client is not connected.</exception>
    /// <example>
    /// <code>
    /// var response = await client.PingAsync("health check");
    /// Console.WriteLine($"Server responded at {response.Timestamp}");
    /// </code>
    /// </example>
    public async Task<PingResponse> PingAsync(string? message = null, CancellationToken cancellationToken = default)
    {
        var connection = await EnsureConnectedAsync(cancellationToken);

        return await InvokeRpcAsync<PingResponse>(
            connection.Rpc, "ping", [new PingRequest { Message = message }], cancellationToken);
    }

    /// <summary>
    /// Gets CLI status including version and protocol information.
    /// </summary>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves with the status response containing version and protocol version.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the client is not connected.</exception>
    public async Task<GetStatusResponse> GetStatusAsync(CancellationToken cancellationToken = default)
    {
        var connection = await EnsureConnectedAsync(cancellationToken);

        return await InvokeRpcAsync<GetStatusResponse>(
            connection.Rpc, "status.get", [], cancellationToken);
    }

    /// <summary>
    /// Gets current authentication status.
    /// </summary>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves with the authentication status.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the client is not connected.</exception>
    public async Task<GetAuthStatusResponse> GetAuthStatusAsync(CancellationToken cancellationToken = default)
    {
        var connection = await EnsureConnectedAsync(cancellationToken);

        return await InvokeRpcAsync<GetAuthStatusResponse>(
            connection.Rpc, "auth.getStatus", [], cancellationToken);
    }

    /// <summary>
    /// Lists available models with their metadata.
    /// </summary>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves with a list of available models.</returns>
    /// <remarks>
    /// Results are cached after the first successful call to avoid rate limiting.
    /// The cache is cleared when the client disconnects.
    /// </remarks>
    /// <exception cref="InvalidOperationException">Thrown when the client is not connected or not authenticated.</exception>
    public async Task<IList<ModelInfo>> ListModelsAsync(CancellationToken cancellationToken = default)
    {
        await _modelsCacheLock.WaitAsync(cancellationToken);
        try
        {
            // Check cache (already inside lock)
            if (_modelsCache is null)
            {
                IList<ModelInfo> models;
                if (_onListModels is not null)
                {
                    // Use custom handler instead of CLI RPC
                    models = await _onListModels(cancellationToken);
                }
                else
                {
                    var connection = await EnsureConnectedAsync(cancellationToken);

                    // Cache miss - fetch from backend while holding lock
                    var response = await InvokeRpcAsync<GetModelsResponse>(
                        connection.Rpc, "models.list", [], cancellationToken);
                    models = response.Models;
                }

                // Update cache before releasing lock (copy to prevent external mutation)
                _modelsCache = [.. models];
            }

            return [.. _modelsCache]; // Return a copy to prevent cache mutation
        }
        finally
        {
            _modelsCacheLock.Release();
        }
    }

    /// <summary>
    /// Gets the ID of the most recently used session.
    /// </summary>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves with the session ID, or null if no sessions exist.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the client is not connected.</exception>
    /// <example>
    /// <code>
    /// var lastId = await client.GetLastSessionIdAsync();
    /// if (lastId != null)
    /// {
    ///     var session = await client.ResumeSessionAsync(lastId, new() { OnPermissionRequest = PermissionHandler.ApproveAll });
    /// }
    /// </code>
    /// </example>
    public async Task<string?> GetLastSessionIdAsync(CancellationToken cancellationToken = default)
    {
        var connection = await EnsureConnectedAsync(cancellationToken);

        var response = await InvokeRpcAsync<GetLastSessionIdResponse>(
            connection.Rpc, "session.getLastId", [], cancellationToken);

        return response.SessionId;
    }

    /// <summary>
    /// Permanently deletes a session and all its data from disk, including
    /// conversation history, planning state, and artifacts.
    /// </summary>
    /// <param name="sessionId">The ID of the session to delete.</param>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that represents the asynchronous delete operation.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the session does not exist or deletion fails.</exception>
    /// <remarks>
    /// Unlike <see cref="CopilotSession.DisposeAsync"/>, which only releases in-memory
    /// resources and preserves session data for later resumption, this method is
    /// irreversible. The session cannot be resumed after deletion.
    /// </remarks>
    /// <example>
    /// <code>
    /// await client.DeleteSessionAsync("session-123");
    /// </code>
    /// </example>
    public async Task DeleteSessionAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var connection = await EnsureConnectedAsync(cancellationToken);

        var response = await InvokeRpcAsync<DeleteSessionResponse>(
            connection.Rpc, "session.delete", [new DeleteSessionRequest(sessionId)], cancellationToken);

        if (!response.Success)
        {
            throw new InvalidOperationException($"Failed to delete session {sessionId}: {response.Error}");
        }

        RemoveSession(sessionId);
    }

    /// <summary>
    /// Lists all sessions known to the Copilot server.
    /// </summary>
    /// <param name="filter">Optional filter to narrow down the session list by cwd, git root, repository, or branch.</param>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves with a list of <see cref="SessionMetadata"/> for all available sessions.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the client is not connected.</exception>
    /// <example>
    /// <code>
    /// var sessions = await client.ListSessionsAsync();
    /// foreach (var session in sessions)
    /// {
    ///     Console.WriteLine($"{session.SessionId}: {session.Summary}");
    /// }
    /// </code>
    /// </example>
    public async Task<IList<SessionMetadata>> ListSessionsAsync(SessionListFilter? filter = null, CancellationToken cancellationToken = default)
    {
        var connection = await EnsureConnectedAsync(cancellationToken);

        var response = await InvokeRpcAsync<ListSessionsResponse>(
            connection.Rpc, "session.list", [new ListSessionsRequest(filter)], cancellationToken);

        return response.Sessions;
    }

    /// <summary>
    /// Gets metadata for a specific session by ID.
    /// </summary>
    /// <remarks>
    /// This provides an efficient O(1) lookup of a single session's metadata
    /// instead of listing all sessions.
    /// </remarks>
    /// <param name="sessionId">The ID of the session to look up.</param>
    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
    /// <returns>A task that resolves with the <see cref="SessionMetadata"/>, or null if the session was not found.</returns>
    /// <exception cref="InvalidOperationException">Thrown when the client is not connected.</exception>
    /// <example>
    /// <code>
    /// var metadata = await client.GetSessionMetadataAsync("session-123");
    /// if (metadata != null)
    /// {
    ///     Console.WriteLine($"Session started at: {metadata.StartTime}");
    /// }
    /// </code>
    /// </example>
    public async Task<SessionMetadata?> GetSessionMetadataAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var connection = await EnsureConnectedAsync(cancellationToken);

        var response = await InvokeRpcAsync<GetSessionMetadataResponse>(
            connection.Rpc, "session.getMetadata", [new GetSessionMetadataRequest(sessionId)], cancellationToken);

        return response.Session;
    }

    /// <summary>
    /// Gets the ID of the session currently displayed in the TUI.
    /// </summary>
    /// <remarks>
    /// This is only available when connecting to a server running in TUI+server mode
    /// (--ui-server).
    /// </remarks>
    /// <param name="cancellationToken">A token to cancel the operation.</param>
    /// <returns>The session ID, or null if no foreground session is set.</returns>
    /// <example>
    /// <code>
    /// var sessionId = await client.GetForegroundSessionIdAsync();
    /// if (sessionId != null)
    /// {
    ///     Console.WriteLine($"TUI is displaying session: {sessionId}");
    /// }
    /// </code>
    /// </example>
    public async Task<string?> GetForegroundSessionIdAsync(CancellationToken cancellationToken = default)
    {
        var connection = await EnsureConnectedAsync(cancellationToken);

        var response = await InvokeRpcAsync<GetForegroundSessionResponse>(
            connection.Rpc, "session.getForeground", [], cancellationToken);

        return response.SessionId;
    }

    /// <summary>
    /// Requests the TUI to switch to displaying the specified session.
    /// </summary>
    /// <remarks>
    /// This is only available when connecting to a server running in TUI+server mode
    /// (--ui-server).
    /// </remarks>
    /// <param name="sessionId">The ID of the session to display in the TUI.</param>
    /// <param name="cancellationToken">A token to cancel the operation.</param>
    /// <exception cref="InvalidOperationException">Thrown if the operation fails.</exception>
    /// <example>
    /// <code>
    /// await client.SetForegroundSessionIdAsync("session-123");
    /// </code>
    /// </example>
    public async Task SetForegroundSessionIdAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var connection = await EnsureConnectedAsync(cancellationToken);

        var response = await InvokeRpcAsync<SetForegroundSessionResponse>(
            connection.Rpc, "session.setForeground", [new SetForegroundSessionRequest(sessionId)], cancellationToken);

        if (!response.Success)
        {
            throw new InvalidOperationException(response.Error ?? "Failed to set foreground session");
        }
    }

    /// <summary>
    /// Subscribes to all session lifecycle events.
    /// </summary>
    /// <remarks>
    /// Lifecycle events are emitted when sessions are created, deleted, updated,
    /// or change foreground/background state (in TUI+server mode).
    /// </remarks>
    /// <param name="handler">A callback function that receives lifecycle events.</param>
    /// <returns>An IDisposable that, when disposed, unsubscribes the handler.</returns>
    /// <example>
    /// <code>
    /// using var subscription = client.On(evt =>
    /// {
    ///     Console.WriteLine($"Session {evt.SessionId}: {evt.Type}");
    /// });
    /// </code>
    /// </example>
    public IDisposable On(Action<SessionLifecycleEvent> handler)
    {
        ArgumentNullException.ThrowIfNull(handler);

        lock (_lifecycleHandlersLock)
        {
            _lifecycleHandlers.Add(handler);
        }

        return new ActionDisposable(() =>
        {
            lock (_lifecycleHandlersLock)
            {
                _lifecycleHandlers.Remove(handler);
            }
        });
    }

    /// <summary>
    /// Subscribes to a specific session lifecycle event type.
    /// </summary>
    /// <param name="eventType">The event type to listen for (use SessionLifecycleEventTypes constants).</param>
    /// <param name="handler">A callback function that receives events of the specified type.</param>
    /// <returns>An IDisposable that, when disposed, unsubscribes the handler.</returns>
    /// <example>
    /// <code>
    /// using var subscription = client.On(SessionLifecycleEventTypes.Foreground, evt =>
    /// {
    ///     Console.WriteLine($"Session {evt.SessionId} is now in foreground");
    /// });
    /// </code>
    /// </example>
    public IDisposable On(string eventType, Action<SessionLifecycleEvent> handler)
    {
        ArgumentNullException.ThrowIfNull(eventType);
        ArgumentNullException.ThrowIfNull(handler);

        lock (_lifecycleHandlersLock)
        {
            if (!_typedLifecycleHandlers.TryGetValue(eventType, out var handlers))
            {
                handlers = [];
                _typedLifecycleHandlers[eventType] = handlers;
            }

            handlers.Add(handler);
        }

        return new ActionDisposable(() =>
        {
            lock (_lifecycleHandlersLock)
            {
                if (_typedLifecycleHandlers.TryGetValue(eventType, out var handlers))
                {
                    handlers.Remove(handler);
                }
            }
        });
    }

    private void DispatchLifecycleEvent(SessionLifecycleEvent evt)
    {
        List<Action<SessionLifecycleEvent>> typedHandlers;
        List<Action<SessionLifecycleEvent>> wildcardHandlers;

        lock (_lifecycleHandlersLock)
        {
            typedHandlers = _typedLifecycleHandlers.TryGetValue(evt.Type, out var handlers)
                ? [.. handlers]
                : [];
            wildcardHandlers = [.. _lifecycleHandlers];
        }

        foreach (var handler in typedHandlers)
        {
            try { handler(evt); } catch { /* Ignore handler errors */ }
        }

        foreach (var handler in wildcardHandlers)
        {
            try { handler(evt); } catch { /* Ignore handler errors */ }
        }
    }

    internal static Task<T> InvokeRpcAsync<T>(JsonRpc rpc, string method, object?[]? args, CancellationToken cancellationToken)
    {
        return InvokeRpcAsync<T>(rpc, method, args, null, cancellationToken);
    }

    internal static Task InvokeRpcAsync(JsonRpc rpc, string method, object?[]? args, CancellationToken cancellationToken)
    {
        return InvokeRpcAsync<object>(rpc, method, args, null, cancellationToken);
    }

    internal static Task<T> InvokeRpcAsync<T>(SessionRpc rpc, string method, object?[]? args, CancellationToken cancellationToken)
    {
        return InvokeRpcAsync<T>(rpc.Session.JsonRpc, method, args, cancellationToken);
    }

    internal static Task InvokeRpcAsync(SessionRpc rpc, string method, object?[]? args, CancellationToken cancellationToken)
    {
        return InvokeRpcAsync<object>(rpc, method, args, cancellationToken);
    }

    internal static async Task<T> InvokeRpcAsync<T>(JsonRpc rpc, string method, object?[]? args, StringBuilder? stderrBuffer, CancellationToken cancellationToken)
    {
        try
        {
            return await rpc.InvokeAsync<T>(method, args, cancellationToken);
        }
        catch (ConnectionLostException ex)
        {
            string? stderrOutput = null;
            if (stderrBuffer is not null)
            {
                lock (stderrBuffer)
                {
                    stderrOutput = stderrBuffer.ToString().Trim();
                }
            }

            if (!string.IsNullOrEmpty(stderrOutput))
            {
                throw new IOException(FormatCliExitedMessage("CLI process exited unexpectedly.", stderrOutput!), ex);
            }
            throw new IOException($"Communication error with Copilot CLI: {ex.Message}", ex);
        }
        catch (RemoteRpcException ex)
        {
            throw new IOException($"Communication error with Copilot CLI: {ex.Message}", ex);
        }
    }

    private static string FormatCliExitedMessage(string message, string stderrOutput)
    {
        return string.IsNullOrEmpty(stderrOutput)
            ? message
            : $"{message}\nstderr: {stderrOutput}";
    }

    [LoggerMessage(
        Level = LogLevel.Information,
        Message = "CopilotClient.StartCliServerAsync starting Copilot CLI. CliPath={CliPath}, Executable={Executable}, CliPathSource={CliPathSource}, UseStdio={UseStdio}, Port={Port}")]
    private static partial void LogStartingCopilotCli(ILogger logger, string cliPath, string executable, string cliPathSource, bool useStdio, int? port);

    [LoggerMessage(
        Level = LogLevel.Information,
        Message = "CopilotClient.ConnectToServerAsync connecting to CLI server. Host={Host}, Port={Port}")]
    private static partial void LogConnectingToCliServer(ILogger logger, string host, int port);

    private static IOException CreateCliExitedException(string message, StringBuilder stderrBuffer)
    {
        string stderrOutput;
        lock (stderrBuffer)
        {
            stderrOutput = stderrBuffer.ToString().Trim();
        }

        return new IOException(FormatCliExitedMessage(message, stderrOutput));
    }

    private Task<Connection> EnsureConnectedAsync(CancellationToken cancellationToken)
    {
        if (_connectionTask is null && !_options.AutoStart)
        {
            throw new InvalidOperationException($"Client not connected. Call {nameof(StartAsync)}() first.");
        }

        // If already started or starting, this will return the existing task
        return (Task<Connection>)StartAsync(cancellationToken);
    }

    private async Task ConfigureSessionFsAsync(CancellationToken cancellationToken)
    {
        if (_options.SessionFs is null)
        {
            return;
        }

        await Rpc.SessionFs.SetProviderAsync(
            _options.SessionFs.InitialCwd,
            _options.SessionFs.SessionStatePath,
            _options.SessionFs.Conventions,
            _options.SessionFs.Capabilities,
            cancellationToken: cancellationToken);
    }

    private void ConfigureSessionFsHandlers(CopilotSession session, Func<CopilotSession, SessionFsProvider>? createSessionFsHandler)
    {
        if (_options.SessionFs is null)
        {
            return;
        }

        if (createSessionFsHandler is null)
        {
            throw new InvalidOperationException(
                "CreateSessionFsHandler is required in the session config when CopilotClientOptions.SessionFs is configured.");
        }

        var provider = createSessionFsHandler(session)
            ?? throw new InvalidOperationException("CreateSessionFsHandler returned null.");

        if (_options.SessionFs.Capabilities?.Sqlite == true && provider is not ISessionFsSqliteProvider)
        {
            throw new InvalidOperationException(
                "SessionFsConfig declares capabilities.sqlite but the provider does not implement ISessionFsSqliteProvider.");
        }

        session.ClientSessionApis.SessionFs = provider;
    }

    private async Task VerifyProtocolVersionAsync(Connection connection, CancellationToken cancellationToken)
    {
        var handshakeTimestamp = Stopwatch.GetTimestamp();
        var usedFallbackPing = false;
        var maxVersion = SdkProtocolVersion.GetVersion();
        int? serverVersion;
        try
        {
            var connectResponse = await InvokeRpcAsync<ConnectResult>(
                connection.Rpc, "connect", [new ConnectRequest { Token = _effectiveConnectionToken }], connection.StderrBuffer, cancellationToken);
            serverVersion = (int)connectResponse.ProtocolVersion;
        }
        catch (IOException ex) when (ex.InnerException is RemoteRpcException remoteEx && IsUnsupportedConnectMethod(remoteEx))
        {
            // Legacy server without `connect`; fall back to `ping`. A token, if any,
            // is silently dropped — the legacy server can't enforce one.
            usedFallbackPing = true;
            var pingResponse = await InvokeRpcAsync<PingResponse>(
                connection.Rpc, "ping", [new PingRequest()], connection.StderrBuffer, cancellationToken);
            serverVersion = pingResponse.ProtocolVersion;
        }

        if (!serverVersion.HasValue)
        {
            throw new InvalidOperationException(
                $"SDK protocol version mismatch: SDK supports versions {MinProtocolVersion}-{maxVersion}, " +
                $"but server does not report a protocol version. " +
                $"Please update your server to ensure compatibility.");
        }

        if (serverVersion.Value < MinProtocolVersion || serverVersion.Value > maxVersion)
        {
            throw new InvalidOperationException(
                $"SDK protocol version mismatch: SDK supports versions {MinProtocolVersion}-{maxVersion}, " +
                $"but server reports version {serverVersion.Value}. " +
                $"Please update your SDK or server to ensure compatibility.");
        }

        _negotiatedProtocolVersion = serverVersion.Value;
        LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
            "CopilotClient.VerifyProtocolVersionAsync protocol handshake complete. Elapsed={Elapsed}, ProtocolVersion={ProtocolVersion}, UsedFallbackPing={UsedFallbackPing}",
            handshakeTimestamp,
            serverVersion.Value,
            usedFallbackPing);
    }

    private static bool IsUnsupportedConnectMethod(RemoteRpcException ex)
    {
        return ex.ErrorCode == RemoteRpcException.MethodNotFoundErrorCode
            || string.Equals(ex.Message, "Unhandled method connect", StringComparison.Ordinal);
    }

    private static async Task<(Process Process, int? DetectedLocalhostTcpPort, StringBuilder StderrBuffer)> StartCliServerAsync(CopilotClientOptions options, string? connectionToken, ILogger logger, CancellationToken cancellationToken)
    {
        // Use explicit path, COPILOT_CLI_PATH env var (from options.Environment or process env), or bundled CLI - no PATH fallback
        var envCliPath = options.Environment is not null && options.Environment.TryGetValue("COPILOT_CLI_PATH", out var envValue) ? envValue
            : System.Environment.GetEnvironmentVariable("COPILOT_CLI_PATH");
        var cliPath = options.CliPath
            ?? envCliPath
            ?? GetBundledCliPath(out var searchedPath)
            ?? throw new InvalidOperationException($"Copilot CLI not found at '{searchedPath}'. Ensure the SDK NuGet package was restored correctly or provide an explicit CliPath.");
        var cliPathSource = options.CliPath is not null ? "Options" : envCliPath is not null ? "Environment" : "Bundled";
        var args = new List<string>();

        if (options.CliArgs != null)
        {
            args.AddRange(options.CliArgs);
        }

        args.AddRange(["--headless", "--no-auto-update", "--log-level", options.LogLevel]);

        if (options.UseStdio == true)
        {
            args.Add("--stdio");
        }
        else if (options.Port > 0)
        {
            args.AddRange(["--port", options.Port.ToString(CultureInfo.InvariantCulture)]);
        }

        // Add auth-related flags
        if (!string.IsNullOrEmpty(options.GitHubToken))
        {
            args.AddRange(["--auth-token-env", "COPILOT_SDK_AUTH_TOKEN"]);
        }

        // Default UseLoggedInUser to false when GitHubToken is provided
        var useLoggedInUser = options.UseLoggedInUser ?? string.IsNullOrEmpty(options.GitHubToken);
        if (!useLoggedInUser)
        {
            args.Add("--no-auto-login");
        }

        if (options.SessionIdleTimeoutSeconds is > 0)
        {
            args.AddRange(["--session-idle-timeout", options.SessionIdleTimeoutSeconds.Value.ToString(CultureInfo.InvariantCulture)]);
        }

        if (options.Remote)
        {
            args.Add("--remote");
        }

        var (fileName, processArgs) = ResolveCliCommand(cliPath, args);
        var configuredPort = options.UseStdio == true ? (int?)null : options.Port;
        LogStartingCopilotCli(logger, cliPath, fileName, cliPathSource, options.UseStdio == true, configuredPort);

        var startInfo = new ProcessStartInfo
        {
            FileName = fileName,
            Arguments = string.Join(" ", processArgs.Select(ProcessArgumentEscaper.Escape)),
            UseShellExecute = false,
            RedirectStandardInput = options.UseStdio == true,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            WorkingDirectory = options.Cwd,
            CreateNoWindow = true
        };

        if (options.Environment != null)
        {
            startInfo.Environment.Clear();
            foreach (var (key, value) in options.Environment)
            {
                startInfo.Environment[key] = value;
            }
        }

        startInfo.Environment.Remove("NODE_DEBUG");

        // Set auth token in environment if provided
        if (!string.IsNullOrEmpty(options.GitHubToken))
        {
            startInfo.Environment["COPILOT_SDK_AUTH_TOKEN"] = options.GitHubToken;
        }

        if (!string.IsNullOrEmpty(connectionToken))
        {
            startInfo.Environment["COPILOT_CONNECTION_TOKEN"] = connectionToken;
        }

        if (!string.IsNullOrEmpty(options.CopilotHome))
        {
            startInfo.Environment["COPILOT_HOME"] = options.CopilotHome;
        }

        // Set telemetry environment variables if configured
        if (options.Telemetry is { } telemetry)
        {
            startInfo.Environment["COPILOT_OTEL_ENABLED"] = "true";
            if (telemetry.OtlpEndpoint is not null) startInfo.Environment["OTEL_EXPORTER_OTLP_ENDPOINT"] = telemetry.OtlpEndpoint;
            if (telemetry.FilePath is not null) startInfo.Environment["COPILOT_OTEL_FILE_EXPORTER_PATH"] = telemetry.FilePath;
            if (telemetry.ExporterType is not null) startInfo.Environment["COPILOT_OTEL_EXPORTER_TYPE"] = telemetry.ExporterType;
            if (telemetry.SourceName is not null) startInfo.Environment["COPILOT_OTEL_SOURCE_NAME"] = telemetry.SourceName;
            if (telemetry.CaptureContent is { } capture) startInfo.Environment["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = capture ? "true" : "false";
        }

        Process? cliProcess = null;
        try
        {
            cliProcess = new Process { StartInfo = startInfo };
            var spawnTimestamp = Stopwatch.GetTimestamp();
            cliProcess.Start();
            LoggingHelpers.LogTiming(logger, LogLevel.Debug, null,
                "CopilotClient.StartCliServerAsync subprocess spawned. Elapsed={Elapsed}",
                spawnTimestamp);

            // Capture stderr for error messages and forward to logger
            var stderrBuffer = new StringBuilder();
            var stderrReader = Task.Run(async () =>
            {
                while (true)
                {
                    var line = await cliProcess.StandardError.ReadLineAsync(cancellationToken);
                    if (line is null)
                    {
                        break;
                    }

                    lock (stderrBuffer)
                    {
                        stderrBuffer.AppendLine(line);
                    }

                    logger.LogWarning("[CLI] {Line}", line);
                }
            }, cancellationToken);

            var detectedLocalhostTcpPort = (int?)null;
            if (options.UseStdio != true)
            {
                // Wait for port announcement
                var portWaitTimestamp = Stopwatch.GetTimestamp();
                using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                cts.CancelAfter(TimeSpan.FromSeconds(30));

                while (!cts.Token.IsCancellationRequested)
                {
                    var line = await cliProcess.StandardOutput.ReadLineAsync(cts.Token);
                    if (line is null)
                    {
                        await stderrReader;
                        throw CreateCliExitedException("CLI process exited unexpectedly", stderrBuffer);
                    }

                    if (logger.IsEnabled(LogLevel.Debug))
                    {
                        logger.LogDebug("[CLI] {Line}", line);
                    }

                    if (ListeningOnPortRegex().Match(line) is { Success: true } match)
                    {
                        detectedLocalhostTcpPort = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
                        LoggingHelpers.LogTiming(logger, LogLevel.Debug, null,
                            "CopilotClient.StartCliServerAsync TCP port wait complete. Elapsed={Elapsed}, Port={Port}",
                            portWaitTimestamp,
                            detectedLocalhostTcpPort.Value);
                        break;
                    }
                }
            }

            return (cliProcess, detectedLocalhostTcpPort, stderrBuffer);
        }
        catch
        {
            if (cliProcess is not null)
            {
                await CleanupCliProcessAsync(cliProcess, errors: null, logger);
            }

            throw;
        }
    }

    private static string? GetBundledCliPath(out string searchedPath)
    {
        var binaryName = OperatingSystem.IsWindows() ? "copilot.exe" : "copilot";
        // Always use portable RID (e.g., linux-x64) to match the build-time placement,
        // since distro-specific RIDs (e.g., ubuntu.24.04-x64) are normalized at build time.
        var rid = GetPortableRid()
            ?? Path.GetFileName(RuntimeInformation.RuntimeIdentifier);
        searchedPath = Path.Combine(AppContext.BaseDirectory, "runtimes", rid, "native", binaryName);
        return File.Exists(searchedPath) ? searchedPath : null;
    }

    private static string? GetPortableRid()
    {
        string os;
        if (OperatingSystem.IsWindows()) os = "win";
        else if (OperatingSystem.IsLinux()) os = "linux";
        else if (OperatingSystem.IsMacOS()) os = "osx";
        else return null;

        var arch = System.Runtime.InteropServices.RuntimeInformation.OSArchitecture switch
        {
            System.Runtime.InteropServices.Architecture.X64 => "x64",
            System.Runtime.InteropServices.Architecture.Arm64 => "arm64",
            _ => null,
        };

        return arch != null ? $"{os}-{arch}" : null;
    }

    private static (string FileName, IEnumerable<string> Args) ResolveCliCommand(string cliPath, IEnumerable<string> args)
    {
        var isJsFile = cliPath.EndsWith(".js", StringComparison.OrdinalIgnoreCase);

        if (isJsFile)
        {
            return ("node", new[] { cliPath }.Concat(args));
        }

        return (cliPath, args);
    }

    private async Task<Connection> ConnectToServerAsync(Process? cliProcess, string? tcpHost, int? tcpPort, StringBuilder? stderrBuffer, CancellationToken cancellationToken)
    {
        var setupTimestamp = Stopwatch.GetTimestamp();
        Stream inputStream, outputStream;
        NetworkStream? networkStream = null;

        if (_options.UseStdio == true)
        {
            if (cliProcess == null)
            {
                throw new InvalidOperationException("CLI process not started");
            }

            inputStream = cliProcess.StandardOutput.BaseStream;
            outputStream = cliProcess.StandardInput.BaseStream;
        }
        else
        {
            if (tcpHost is null || tcpPort is null)
            {
                throw new InvalidOperationException("Cannot connect because TCP host or port are not available");
            }

            var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
            try
            {
                var tcpConnectTimestamp = Stopwatch.GetTimestamp();
                LogConnectingToCliServer(_logger, tcpHost, tcpPort.Value);
                await socket.ConnectAsync(tcpHost, tcpPort.Value, cancellationToken);
                LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
                    "CopilotClient.ConnectToServerAsync TCP connect complete. Elapsed={Elapsed}, Host={Host}, Port={Port}",
                    tcpConnectTimestamp,
                    tcpHost,
                    tcpPort.Value);
            }
            catch
            {
                socket.Dispose();
                throw;
            }

            inputStream = outputStream = networkStream = new NetworkStream(socket, ownsSocket: true);
        }

        var rpc = new JsonRpc(
            outputStream,
            inputStream,
            SerializerOptionsForMessageFormatter,
            _logger);

        var handler = new RpcHandler(this);
        rpc.SetLocalRpcMethod("session.event", handler.OnSessionEvent);
        rpc.SetLocalRpcMethod("session.lifecycle", handler.OnSessionLifecycle);
        // Protocol v3 servers send tool calls / permission requests as broadcast events.
        // Protocol v2 servers use the older tool.call / permission.request RPC model.
        // We always register v2 adapters because handlers are set up before version
        // negotiation; a v3 server will simply never send these requests.
        rpc.SetLocalRpcMethod("tool.call", handler.OnToolCallV2);
        rpc.SetLocalRpcMethod("permission.request", handler.OnPermissionRequestV2);
        rpc.SetLocalRpcMethod("userInput.request", handler.OnUserInputRequest);
        rpc.SetLocalRpcMethod("exitPlanMode.request", handler.OnExitPlanModeRequest);
        rpc.SetLocalRpcMethod("autoModeSwitch.request", handler.OnAutoModeSwitchRequest);
        rpc.SetLocalRpcMethod("hooks.invoke", handler.OnHooksInvoke);
        rpc.SetLocalRpcMethod("systemMessage.transform", handler.OnSystemMessageTransform);
        ClientSessionApiRegistration.RegisterClientSessionApiHandlers(rpc, sessionId =>
        {
            var session = GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
            return session.ClientSessionApis;
        });
        rpc.StartListening();
        LoggingHelpers.LogTiming(_logger, LogLevel.Debug, null,
            "CopilotClient.ConnectToServerAsync transport setup complete. Elapsed={Elapsed}",
            setupTimestamp);

        // Transition state to Disconnected if the JSON-RPC connection drops
        _ = rpc.Completion.ContinueWith(_ => _disconnected = true, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

        _serverRpc = new ServerRpc(rpc);

        return new Connection(rpc, cliProcess, networkStream, stderrBuffer);
    }

    private static JsonSerializerOptions SerializerOptionsForMessageFormatter { get; } = CreateSerializerOptions();

    private static JsonSerializerOptions CreateSerializerOptions()
    {
        var options = new JsonSerializerOptions(JsonSerializerDefaults.Web)
        {
            AllowOutOfOrderMetadataProperties = true,
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
        };

        options.TypeInfoResolverChain.Add(ClientJsonContext.Default);
        options.TypeInfoResolverChain.Add(TypesJsonContext.Default);
        options.TypeInfoResolverChain.Add(CopilotSession.SessionJsonContext.Default);
        options.TypeInfoResolverChain.Add(SessionEventsJsonContext.Default);
        options.TypeInfoResolverChain.Add(SDK.Rpc.RpcJsonContext.Default);

        options.MakeReadOnly();

        return options;
    }

    internal CopilotSession? GetSession(string sessionId)
    {
        _sessions.TryGetValue(sessionId, out var session);
        return session;
    }

    private void RegisterSession(CopilotSession session)
    {
        if (!_sessions.TryAdd(session.SessionId, session))
        {
            throw new InvalidOperationException($"Session '{session.SessionId}' is already tracked by this client.");
        }
    }

    private void RemoveSession(string sessionId)
    {
        _sessions.TryRemove(sessionId, out _);
    }

    /// <summary>
    /// Disposes the <see cref="CopilotClient"/> synchronously.
    /// </summary>
    /// <remarks>
    /// Prefer using <see cref="DisposeAsync"/> for better performance in async contexts.
    /// </remarks>
    public void Dispose()
    {
        DisposeAsync().AsTask().GetAwaiter().GetResult();
    }

    /// <summary>
    /// Disposes the <see cref="CopilotClient"/> asynchronously.
    /// </summary>
    /// <returns>A <see cref="ValueTask"/> representing the asynchronous dispose operation.</returns>
    /// <remarks>
    /// This method calls <see cref="ForceStopAsync"/> to immediately release all resources.
    /// </remarks>
    public async ValueTask DisposeAsync()
    {
        if (_disposed) return;
        _disposed = true;
        await ForceStopAsync();
    }

    private class RpcHandler(CopilotClient client)
    {
        public void OnSessionEvent(string sessionId, JsonElement? @event)
        {
            var session = client.GetSession(sessionId);
            if (session != null && @event != null)
            {
                var evt = SessionEvent.FromJson(@event.Value.GetRawText());
                if (evt != null)
                {
                    session.DispatchEvent(evt);
                }
            }
        }

        public void OnSessionLifecycle(string type, string sessionId, JsonElement? metadata)
        {
            var evt = new SessionLifecycleEvent
            {
                Type = type,
                SessionId = sessionId
            };

            if (metadata != null)
            {
                evt.Metadata = JsonSerializer.Deserialize(
                    metadata.Value.GetRawText(),
                    TypesJsonContext.Default.SessionLifecycleEventMetadata);
            }

            client.DispatchLifecycleEvent(evt);
        }

        public async ValueTask<UserInputRequestResponse> OnUserInputRequest(string sessionId, string question, IList<string>? choices = null, bool? allowFreeform = null)
        {
            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
            var request = new UserInputRequest
            {
                Question = question,
                Choices = choices,
                AllowFreeform = allowFreeform
            };

            var result = await session.HandleUserInputRequestAsync(request);
            return new UserInputRequestResponse(result.Answer, result.WasFreeform);
        }

        public async ValueTask<ExitPlanModeResult> OnExitPlanModeRequest(
            string sessionId,
            string summary,
            string? planContent = null,
            IList<string>? actions = null,
            string? recommendedAction = null)
        {
            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
            var request = new ExitPlanModeRequest
            {
                Summary = summary,
                PlanContent = planContent,
                Actions = actions ?? [],
                RecommendedAction = recommendedAction ?? "autopilot"
            };

            return await session.HandleExitPlanModeRequestAsync(request);
        }

        public async ValueTask<AutoModeSwitchRequestResponse> OnAutoModeSwitchRequest(
            string sessionId,
            string? errorCode = null,
            double? retryAfterSeconds = null)
        {
            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
            var response = await session.HandleAutoModeSwitchRequestAsync(new AutoModeSwitchRequest
            {
                ErrorCode = errorCode,
                RetryAfterSeconds = retryAfterSeconds
            });
            return new AutoModeSwitchRequestResponse(response);
        }

        public async ValueTask<HooksInvokeResponse> OnHooksInvoke(string sessionId, string hookType, JsonElement input)
        {
            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
            var output = await session.HandleHooksInvokeAsync(hookType, input);
            return new HooksInvokeResponse(output);
        }

        public async ValueTask<SystemMessageTransformRpcResponse> OnSystemMessageTransform(string sessionId, JsonElement sections)
        {
            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
            return await session.HandleSystemMessageTransformAsync(sections);
        }

        // Protocol v2 backward-compatibility adapters

        public async ValueTask<ToolCallResponseV2> OnToolCallV2(string sessionId,
            string toolCallId,
            string toolName,
            object? arguments,
            string? traceparent = null,
            string? tracestate = null)
        {
            using var _ = TelemetryHelpers.RestoreTraceContext(traceparent, tracestate);

            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
            if (session.GetTool(toolName) is not { } tool)
            {
                // Support for not providing the tool handler is only available in the v3+ model.
                // For v2, it must have been provided.
                return new ToolCallResponseV2(new ToolResultObject
                {
                    TextResultForLlm = $"Tool '{toolName}' is not supported.",
                    ResultType = "failure",
                    Error = $"tool '{toolName}' not supported"
                });
            }

            try
            {
                var invocation = new ToolInvocation
                {
                    SessionId = sessionId,
                    ToolCallId = toolCallId,
                    ToolName = toolName,
                    Arguments = arguments
                };

                var aiFunctionArgs = new AIFunctionArguments
                {
                    Context = new Dictionary<object, object?>
                    {
                        [typeof(ToolInvocation)] = invocation
                    }
                };

                if (arguments is not null)
                {
                    if (arguments is not JsonElement incomingJsonArgs)
                    {
                        throw new InvalidOperationException($"Incoming arguments must be a {nameof(JsonElement)}; received {arguments.GetType().Name}");
                    }

                    foreach (var prop in incomingJsonArgs.EnumerateObject())
                    {
                        aiFunctionArgs[prop.Name] = prop.Value;
                    }
                }

                var toolTimestamp = Stopwatch.GetTimestamp();
                var result = await tool.InvokeAsync(aiFunctionArgs);
                LoggingHelpers.LogTiming(client._logger, LogLevel.Debug, null,
                    "RpcHandler.OnToolCallV2 tool dispatch. Elapsed={Elapsed}, SessionId={SessionId}, ToolCallId={ToolCallId}, Tool={ToolName}",
                    toolTimestamp,
                    sessionId,
                    toolCallId,
                    toolName);

                var toolResultObject = ToolResultObject.ConvertFromInvocationResult(result, tool.JsonSerializerOptions);
                return new ToolCallResponseV2(toolResultObject);
            }
            catch (Exception ex)
            {
                return new ToolCallResponseV2(new ToolResultObject
                {
                    TextResultForLlm = "Invoking this tool produced an error. Detailed information is not available.",
                    ResultType = "failure",
                    Error = ex.Message
                });
            }
        }

        public async ValueTask<PermissionRequestResponseV2> OnPermissionRequestV2(string sessionId, JsonElement permissionRequest)
        {
            var session = client.GetSession(sessionId)
                ?? throw new ArgumentException($"Unknown session {sessionId}");

            try
            {
                var result = await session.HandlePermissionRequestAsync(permissionRequest);
                if (result.Kind == new PermissionRequestResultKind("no-result"))
                {
                    throw new InvalidOperationException(NoResultPermissionV2ErrorMessage);
                }
                return new PermissionRequestResponseV2(result);
            }
            catch (InvalidOperationException ex) when (ex.Message == NoResultPermissionV2ErrorMessage)
            {
                throw;
            }
            catch (Exception)
            {
                return new PermissionRequestResponseV2(new PermissionRequestResult
                {
                    Kind = PermissionRequestResultKind.UserNotAvailable
                });
            }
        }
    }

    private class Connection(
        JsonRpc rpc,
        Process? cliProcess, // Set if we created the child process
        NetworkStream? networkStream, // Set if using TCP
        StringBuilder? stderrBuffer = null) // Captures stderr for error messages
    {
        public Process? CliProcess => cliProcess;
        public JsonRpc Rpc => rpc;
        public NetworkStream? NetworkStream => networkStream;
        public StringBuilder? StderrBuffer => stderrBuffer;
    }

    private static class ProcessArgumentEscaper
    {
        public static string Escape(string arg)
        {
            if (string.IsNullOrEmpty(arg)) return "\"\"";
            if (!arg.Contains(' ') && !arg.Contains('"')) return arg;
            return "\"" + arg.Replace("\"", "\\\"") + "\"";
        }
    }

    // Request/Response types for RPC
    internal record CreateSessionRequest(
        string? Model,
        string? SessionId,
        string? ClientName,
        string? ReasoningEffort,
        IList<ToolDefinition>? Tools,
        SystemMessageConfig? SystemMessage,
        IList<string>? AvailableTools,
        IList<string>? ExcludedTools,
        ProviderConfig? Provider,
        bool? EnableSessionTelemetry,
        bool? RequestPermission,
        bool? RequestUserInput,
        bool? RequestExitPlanMode,
        bool? RequestAutoModeSwitch,
        bool? Hooks,
        string? WorkingDirectory,
        bool? Streaming,
        bool? IncludeSubAgentStreamingEvents,
        IDictionary<string, McpServerConfig>? McpServers,
        string? EnvValueMode,
        IList<CustomAgentConfig>? CustomAgents,
        DefaultAgentConfig? DefaultAgent,
        string? Agent,
        string? ConfigDir,
        bool? EnableConfigDiscovery,
        IList<string>? SkillDirectories,
        IList<string>? DisabledSkills,
        InfiniteSessionConfig? InfiniteSessions,
        IList<CommandWireDefinition>? Commands = null,
        bool? RequestElicitation = null,
        string? Traceparent = null,
        string? Tracestate = null,
        ModelCapabilitiesOverride? ModelCapabilities = null,
        string? GitHubToken = null,
        RemoteSessionMode? RemoteSession = null,
        CloudSessionOptions? Cloud = null,
        IList<string>? InstructionDirectories = null);

    internal record ToolDefinition(
        string Name,
        string? Description,
        JsonElement Parameters, /* JSON schema */
        bool? OverridesBuiltInTool = null,
        bool? SkipPermission = null)
    {
        public static ToolDefinition FromAIFunction(AIFunctionDeclaration function)
        {
            var overrides = function.AdditionalProperties.TryGetValue(CopilotTool.OverridesBuiltInToolKey, out var val) && val is true;
            var skipPerm = function.AdditionalProperties.TryGetValue(CopilotTool.SkipPermissionKey, out var skipVal) && skipVal is true;
            return new ToolDefinition(function.Name, function.Description, function.JsonSchema,
                overrides ? true : null,
                skipPerm ? true : null);
        }
    }

    internal record CreateSessionResponse(
        string SessionId,
        string? WorkspacePath,
        SessionCapabilities? Capabilities = null);

    internal record ResumeSessionRequest(
        string SessionId,
        string? ClientName,
        string? Model,
        string? ReasoningEffort,
        IList<ToolDefinition>? Tools,
        SystemMessageConfig? SystemMessage,
        IList<string>? AvailableTools,
        IList<string>? ExcludedTools,
        ProviderConfig? Provider,
        bool? EnableSessionTelemetry,
        bool? RequestPermission,
        bool? RequestUserInput,
        bool? RequestExitPlanMode,
        bool? RequestAutoModeSwitch,
        bool? Hooks,
        string? WorkingDirectory,
        string? ConfigDir,
        bool? EnableConfigDiscovery,
        bool? DisableResume,
        bool? Streaming,
        bool? IncludeSubAgentStreamingEvents,
        IDictionary<string, McpServerConfig>? McpServers,
        string? EnvValueMode,
        IList<CustomAgentConfig>? CustomAgents,
        DefaultAgentConfig? DefaultAgent,
        string? Agent,
        IList<string>? SkillDirectories,
        IList<string>? DisabledSkills,
        InfiniteSessionConfig? InfiniteSessions,
        IList<CommandWireDefinition>? Commands = null,
        bool? RequestElicitation = null,
        string? Traceparent = null,
        string? Tracestate = null,
        ModelCapabilitiesOverride? ModelCapabilities = null,
        string? GitHubToken = null,
        RemoteSessionMode? RemoteSession = null,
        bool? ContinuePendingWork = null,
        IList<string>? InstructionDirectories = null);

    internal record ResumeSessionResponse(
        string SessionId,
        string? WorkspacePath,
        SessionCapabilities? Capabilities = null);

    internal record CommandWireDefinition(
        string Name,
        string? Description);

    internal record GetLastSessionIdResponse(
        string? SessionId);

    internal record DeleteSessionRequest(
        string SessionId);

    internal record DeleteSessionResponse(
        bool Success,
        string? Error);

    internal record ListSessionsRequest(
        SessionListFilter? Filter);

    internal record ListSessionsResponse(
        List<SessionMetadata> Sessions);

    internal record GetSessionMetadataRequest(
        string SessionId);

    internal record GetSessionMetadataResponse(
        SessionMetadata? Session);

    internal record SetForegroundSessionRequest(
        string SessionId);

    internal record UserInputRequestResponse(
        string Answer,
        bool WasFreeform);

    internal record AutoModeSwitchRequestResponse(
        AutoModeSwitchResponse Response);

    internal record HooksInvokeResponse(
        object? Output);

    // Protocol v2 backward-compatibility response types
    internal record ToolCallResponseV2(
        ToolResultObject Result);

    internal record PermissionRequestResponseV2(
        PermissionRequestResult Result);

    [JsonSourceGenerationOptions(
        JsonSerializerDefaults.Web,
        AllowOutOfOrderMetadataProperties = true,
        NumberHandling = JsonNumberHandling.AllowReadingFromString,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonSerializable(typeof(CreateSessionRequest))]
    [JsonSerializable(typeof(CreateSessionResponse))]
    [JsonSerializable(typeof(AutoModeSwitchRequest))]
    [JsonSerializable(typeof(AutoModeSwitchRequestResponse))]
    [JsonSerializable(typeof(AutoModeSwitchResponse))]
    [JsonSerializable(typeof(CustomAgentConfig))]
    [JsonSerializable(typeof(DeleteSessionRequest))]
    [JsonSerializable(typeof(DeleteSessionResponse))]
    [JsonSerializable(typeof(ExitPlanModeRequest))]
    [JsonSerializable(typeof(ExitPlanModeResult))]
    [JsonSerializable(typeof(GetLastSessionIdResponse))]
    [JsonSerializable(typeof(HooksInvokeResponse))]
    [JsonSerializable(typeof(ListSessionsRequest))]
    [JsonSerializable(typeof(ListSessionsResponse))]
    [JsonSerializable(typeof(GetSessionMetadataRequest))]
    [JsonSerializable(typeof(GetSessionMetadataResponse))]
    [JsonSerializable(typeof(ModelCapabilitiesOverride))]
    [JsonSerializable(typeof(PermissionRequestResult))]
    [JsonSerializable(typeof(PermissionRequestResultKind))]
    [JsonSerializable(typeof(PermissionRequestResponseV2))]
    [JsonSerializable(typeof(ProviderConfig))]
    [JsonSerializable(typeof(ResumeSessionRequest))]
    [JsonSerializable(typeof(ResumeSessionResponse))]
    [JsonSerializable(typeof(SessionCapabilities))]
    [JsonSerializable(typeof(SessionUiCapabilities))]
    [JsonSerializable(typeof(SessionMetadata))]
    [JsonSerializable(typeof(SetForegroundSessionRequest))]
    [JsonSerializable(typeof(SystemMessageConfig))]
    [JsonSerializable(typeof(SystemMessageTransformRpcResponse))]
    [JsonSerializable(typeof(CommandWireDefinition))]
    [JsonSerializable(typeof(ToolCallResponseV2))]
    [JsonSerializable(typeof(ToolDefinition))]
    [JsonSerializable(typeof(ToolResultAIContent))]
    [JsonSerializable(typeof(ToolResultObject))]
    [JsonSerializable(typeof(UserInputRequestResponse))]
    [JsonSerializable(typeof(UserInputRequest))]
    [JsonSerializable(typeof(UserInputResponse))]
    internal partial class ClientJsonContext : JsonSerializerContext;

#if NET8_0_OR_GREATER
    [GeneratedRegex(@"listening on port ([0-9]+)", RegexOptions.IgnoreCase)]
    private static partial Regex ListeningOnPortRegex();
#else
    private static readonly Regex s_listeningOnPortRegex = new(@"listening on port ([0-9]+)", RegexOptions.IgnoreCase);

    private static Regex ListeningOnPortRegex() => s_listeningOnPortRegex;
#endif
}

/// <summary>
/// Wraps a <see cref="ToolResultObject"/> as <see cref="AIContent"/> to pass structured tool results
/// back through Microsoft.Extensions.AI without JSON serialization.
/// </summary>
/// <param name="toolResult">The tool result to wrap.</param>
public class ToolResultAIContent(ToolResultObject toolResult) : AIContent
{
    /// <summary>
    /// Gets the underlying <see cref="ToolResultObject"/>.
    /// </summary>
    public ToolResultObject Result => toolResult;
}