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

// AUTO-GENERATED FILE - DO NOT EDIT
// Generated from: api.schema.json

#pragma warning disable CS0612 // Type or member is obsolete
#pragma warning disable CS0618 // Type or member is obsolete (with message)

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;

namespace GitHub.Copilot.Rpc;

/// <summary>Server liveness response, including the echoed message, current server timestamp, and protocol version.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PingResult
{
    /// <summary>Echoed message (or default greeting).</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>Server protocol version number.</summary>
    [JsonPropertyName("protocolVersion")]
    public long ProtocolVersion { get; set; }

    /// <summary>ISO 8601 timestamp when the server handled the ping.</summary>
    [JsonPropertyName("timestamp")]
    public DateTimeOffset Timestamp { get; set; }
}

/// <summary>Optional message to echo back to the caller.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PingRequest
{
    /// <summary>Optional message to echo back.</summary>
    [JsonPropertyName("message")]
    public string? Message { get; set; }
}

/// <summary>Handshake result reporting the server's protocol version and package version on success.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ConnectResult
{
    /// <summary>Always true on success.</summary>
    [JsonPropertyName("ok")]
    public bool Ok { get; set; }

    /// <summary>Server protocol version number.</summary>
    [JsonPropertyName("protocolVersion")]
    public long ProtocolVersion { get; set; }

    /// <summary>Task kinds the server may return to this connection.</summary>
    [JsonPropertyName("taskKinds")]
    public IList<TaskKind>? TaskKinds { get; set; }

    /// <summary>Server package version.</summary>
    [JsonPropertyName("version")]
    public string Version { get; set; } = string.Empty;
}

/// <summary>Identity of the integrating host, declared once on the `server.connect` handshake so telemetry from this connection is attributed to a single, consistent surface. All fields are optional; omit them to keep the default attribution.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ConnectClientInfo
{
    /// <summary>Name of the host editor, e.g. `"vscode"`.</summary>
    [JsonPropertyName("editorName")]
    public string? EditorName { get; set; }

    /// <summary>Version of the host editor, e.g. `"1.124.2"`. Ignored unless it looks like a version string.</summary>
    [JsonPropertyName("editorVersion")]
    public string? EditorVersion { get; set; }

    /// <summary>Name of the Copilot extension within the host, e.g. `"copilot-chat"`.</summary>
    [JsonPropertyName("extensionName")]
    public string? ExtensionName { get; set; }

    /// <summary>Version of the Copilot extension within the host, e.g. `"0.54.0"`. Ignored unless it looks like a version string.</summary>
    [JsonPropertyName("extensionVersion")]
    public string? ExtensionVersion { get; set; }
}

/// <summary>Connection-level opt-ins for the `server.connect` handshake. Transport authentication is consumed by the native protocol boundary before dispatch.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ConnectRequest
{
    /// <summary>Identity of the integrating host. Optional; omit it to keep the default attribution.</summary>
    [JsonPropertyName("clientInfo")]
    public ConnectClientInfo? ClientInfo { get; set; }

    /// <summary>Opt this connection in to GitHub telemetry forwarding for its lifetime. When set, the runtime forwards every internal telemetry event it emits — across all sessions, plus sessionless events — to this connection over the `gitHubTelemetry.event` notification. Regular events are also written to the runtime's normal GitHub/CTS path (dual-write); host-only compatibility events are forward-only and intentionally skip that path. Intended for first-party hosts that re-emit the events into their own telemetry stores. Both unrestricted and restricted events are forwarded, each tagged with a `restricted` discriminator; a backstop drops restricted events when restricted telemetry is disabled — using the process-global gate for ordinary events and an explicit session-scoped decision for host-only events.</summary>
    [JsonPropertyName("enableGitHubTelemetryForwarding")]
    public bool? EnableGitHubTelemetryForwarding { get; set; }

    /// <summary>Task kinds this connection can decode when observing session tasks. Omit to retain agent and shell compatibility.</summary>
    [JsonPropertyName("supportedTaskKinds")]
    public IList<TaskKind>? SupportedTaskKinds { get; set; }

    /// <summary>Connection token; required when the server was started with COPILOT_CONNECTION_TOKEN.</summary>
    [JsonPropertyName("token")]
    public string? Token { get; set; }
}

/// <summary>One server-discovered hook action from user, repository, plugin, or managed-policy configuration.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DiscoveredHook
{
    /// <summary>Durable content hash used by hook enablement. Identical actions may intentionally share this key. Omitted when changing the user's disabled-hooks setting cannot change the action's current server-discovered state, including managed-policy hooks, session-start prompt actions, actions suppressed by disable-all settings, and projectless plugin actions that require project-directory expansion.</summary>
    [JsonPropertyName("disableKey")]
    public string? DisableKey { get; set; }

    /// <summary>Whether this action is enabled under the server-side discovery settings. Concrete sessions may differ because they can add session-specific directories, plugins, or trust. False when its disable key is present in the user's disabled-hooks setting or disable-all settings suppress the action.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Hook event that invokes this action.</summary>
    [JsonPropertyName("hookType")]
    public HookType HookType { get; set; }

    /// <summary>Deterministic identifier for this server-discovered action row. It remains stable while the project, origin, source, event, action content, and duplicate ordinal are unchanged. This is row identity, not the key persisted in disabledHooks.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Configuration tier that contributed this hook action.</summary>
    [JsonPropertyName("origin")]
    public HookOrigin Origin { get; set; }

    /// <summary>Input project path for which this server-side action was resolved. Set on every row returned for project-scoped discovery, including repeated user and policy actions.</summary>
    [JsonPropertyName("projectPath")]
    public string? ProjectPath { get; set; }

    /// <summary>Human-readable source label, such as a hook file path, settings source, or plugin name.</summary>
    [JsonPropertyName("source")]
    public string? Source { get; set; }
}

/// <summary>Server-discovered hook actions and partial-load diagnostics from user, repository, plugin, and managed-policy sources. Concrete sessions may include additional session-specific hook sources.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HooksDiscoverResult
{
    /// <summary>Errors for hook sources or actions that could not be loaded, making the result partially incomplete. Other valid actions are still returned. Project-resolution and repository-settings errors are prefixed with their project path.</summary>
    [JsonPropertyName("errors")]
    public IList<string> Errors { get => field ??= []; set; }

    /// <summary>All discovered hook actions. Byte-identical actions remain separate rows even when they share a disable key.</summary>
    [JsonPropertyName("hooks")]
    public IList<DiscoveredHook> Hooks { get => field ??= []; set; }

    /// <summary>Non-fatal source-loading warnings. Discovery remains complete for the affected source, although the source had a recoverable issue. Repository-settings warnings are prefixed with their project path when attribution is available.</summary>
    [JsonPropertyName("warnings")]
    public IList<string> Warnings { get => field ??= []; set; }
}

/// <summary>Optional project paths and host-exclusion behavior for server-scoped hook discovery.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class HooksDiscoverRequest
{
    /// <summary>When true, omit host-owned user and plugin hook rows and their diagnostics. Managed-policy hooks and trusted repository hooks remain visible, and host disabledHooks still contribute to each remaining row's effective enabled state. This filters sources rather than simulating a host with no settings.</summary>
    [JsonPropertyName("excludeHostHooks")]
    public bool? ExcludeHostHooks { get; set; }

    /// <summary>Optional project directory paths whose trusted repository and project-expanded plugin hooks should be discovered. When omitted or empty, user, managed-policy, and globally enabled installed or explicit plugin hooks are returned without project expansion.</summary>
    [JsonPropertyName("projectPaths")]
    public IList<string>? ProjectPaths { get; set; }
}

/// <summary>Active server-driven promotion for a model, including its discount and optional expiry.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelBillingPromo
{
    /// <summary>Percentage discount (0-100) applied while the promotion is active. May be fractional.</summary>
    [JsonPropertyName("discountPercent")]
    public double? DiscountPercent { get; set; }

    /// <summary>UTC ISO 8601 timestamp marking when the promotion ends. Optional: an open-ended promotion omits this field. When present, the API only surfaces a promo whose expiry parses and is in the future, so consumers should treat a past value as expired.</summary>
    [JsonPropertyName("endsAt")]
    public string? EndsAt { get; set; }

    /// <summary>Stable identifier for the promotion campaign.</summary>
    [JsonPropertyName("id")]
    public string? Id { get; set; }

    /// <summary>Human-readable promotion message. Does not include the expiry timestamp; consumers may format endsAt and append it when present.</summary>
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Whether the service asked hosts to give this promotion a prominent surface, such as a dedicated banner, in addition to listing it with the model. `true` requests that surface and `false` asks for the model list only. Absent means the service expressed no preference — for example a response that predates the field — so hosts should apply their own default rather than read it as `false`.</summary>
    [JsonPropertyName("showBanner")]
    public bool? ShowBanner { get; set; }
}

/// <summary>Long context tier pricing (available for models with extended context windows).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelBillingTokenPricesLongContext
{
    /// <summary>Use cacheReadPrice instead. AI Credits cost per billing batch of cached tokens.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonPropertyName("cachePrice")]
    public double? CachePrice { get; set; }

    /// <summary>AI Credits cost per billing batch of cached (read) tokens.</summary>
    [JsonPropertyName("cacheReadPrice")]
    public double? CacheReadPrice { get; set; }

    /// <summary>AI Credits cost per billing batch of 1-hour cache-write (cache creation) tokens.</summary>
    [JsonPropertyName("cacheWrite1hPrice")]
    public double? CacheWrite1hPrice { get; set; }

    /// <summary>AI Credits cost per billing batch of cache-write (cache creation) tokens.</summary>
    [JsonPropertyName("cacheWritePrice")]
    public double? CacheWritePrice { get; set; }

    /// <summary>Use maxPromptTokens instead. Prompt token budget for the long context tier. The total context window is this value plus the model's max_output_tokens.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonPropertyName("contextMax")]
    public long? ContextMax { get; set; }

    /// <summary>AI Credits cost per billing batch of input tokens.</summary>
    [JsonPropertyName("inputPrice")]
    public double? InputPrice { get; set; }

    /// <summary>Prompt token budget for the long context tier. The total context window is this value plus the model's max_output_tokens.</summary>
    [JsonPropertyName("maxPromptTokens")]
    public long? MaxPromptTokens { get; set; }

    /// <summary>AI Credits cost per billing batch of output tokens.</summary>
    [JsonPropertyName("outputPrice")]
    public double? OutputPrice { get; set; }
}

/// <summary>Token-level pricing information for this model.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelBillingTokenPrices
{
    /// <summary>Number of tokens per standard billing batch.</summary>
    [JsonPropertyName("batchSize")]
    public long? BatchSize { get; set; }

    /// <summary>Use cacheReadPrice instead. AI Credits cost per billing batch of cached tokens.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonPropertyName("cachePrice")]
    public double? CachePrice { get; set; }

    /// <summary>AI Credits cost per billing batch of cached (read) tokens.</summary>
    [JsonPropertyName("cacheReadPrice")]
    public double? CacheReadPrice { get; set; }

    /// <summary>AI Credits cost per billing batch of 1-hour cache-write (cache creation) tokens.</summary>
    [JsonPropertyName("cacheWrite1hPrice")]
    public double? CacheWrite1hPrice { get; set; }

    /// <summary>AI Credits cost per billing batch of cache-write (cache creation) tokens.</summary>
    [JsonPropertyName("cacheWritePrice")]
    public double? CacheWritePrice { get; set; }

    /// <summary>Use maxPromptTokens instead. Prompt token budget for the default tier. The total context window is this value plus the model's max_output_tokens.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonPropertyName("contextMax")]
    public long? ContextMax { get; set; }

    /// <summary>AI Credits cost per billing batch of input tokens.</summary>
    [JsonPropertyName("inputPrice")]
    public double? InputPrice { get; set; }

    /// <summary>Long context tier pricing (available for models with extended context windows).</summary>
    [JsonPropertyName("longContext")]
    public ModelBillingTokenPricesLongContext? LongContext { get; set; }

    /// <summary>Prompt token budget for the default tier. The total context window is this value plus the model's max_output_tokens.</summary>
    [JsonPropertyName("maxPromptTokens")]
    public long? MaxPromptTokens { get; set; }

    /// <summary>AI Credits cost per billing batch of output tokens.</summary>
    [JsonPropertyName("outputPrice")]
    public double? OutputPrice { get; set; }
}

/// <summary>Billing information.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelBilling
{
    /// <summary>Whole-number percentage discount (0-100) applied to usage billed through this model. Populated for the synthetic `auto` model, where requests routed by auto-mode are billed at a reduced rate; absent for concrete models.</summary>
    [JsonPropertyName("discountPercent")]
    public int? DiscountPercent { get; set; }

    /// <summary>Billing cost multiplier relative to the base rate.</summary>
    [JsonPropertyName("multiplier")]
    public double? Multiplier { get; set; }

    /// <summary>Active server-driven promotion for this model, if any. Present when the model is being promoted with a discount, which may be time-boxed or open-ended.</summary>
    [JsonPropertyName("promo")]
    public ModelBillingPromo? Promo { get; set; }

    /// <summary>Token-level pricing information for this model.</summary>
    [JsonPropertyName("tokenPrices")]
    public ModelBillingTokenPrices? TokenPrices { get; set; }
}

/// <summary>Vision-specific limits.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilitiesLimitsVision
{
    /// <summary>Maximum image size in bytes.</summary>
    [JsonPropertyName("max_prompt_image_size")]
    public long MaxPromptImageSize { get; set; }

    /// <summary>Maximum number of images per prompt.</summary>
    [JsonPropertyName("max_prompt_images")]
    public long MaxPromptImages { get; set; }

    /// <summary>MIME types the model accepts.</summary>
    [JsonPropertyName("supported_media_types")]
    public IList<string> SupportedMediaTypes { get => field ??= []; set; }
}

/// <summary>Token limits for prompts, outputs, and context window.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilitiesLimits
{
    /// <summary>Maximum total context window size in tokens.</summary>
    [JsonPropertyName("max_context_window_tokens")]
    public long? MaxContextWindowTokens { get; set; }

    /// <summary>Maximum number of output/completion tokens.</summary>
    [JsonPropertyName("max_output_tokens")]
    public long? MaxOutputTokens { get; set; }

    /// <summary>Maximum number of prompt/input tokens.</summary>
    [JsonPropertyName("max_prompt_tokens")]
    public long? MaxPromptTokens { get; set; }

    /// <summary>Vision-specific limits.</summary>
    [JsonPropertyName("vision")]
    public ModelCapabilitiesLimitsVision? Vision { get; set; }
}

/// <summary>Feature flags indicating what the model supports.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilitiesSupports
{
    /// <summary>Resolved Anthropic adaptive-thinking capability — unsupported / optional / required. 'required' models reject thinking.type='enabled' with HTTP 400 (e.g. opus-4.7/4.8).</summary>
    [JsonPropertyName("adaptive_thinking")]
    public AdaptiveThinkingSupport? AdaptiveThinking { get; set; }

    /// <summary>Whether this model supports reasoning effort configuration.</summary>
    [JsonPropertyName("reasoningEffort")]
    public bool? ReasoningEffort { get; set; }

    /// <summary>Whether this model supports vision/image input.</summary>
    [JsonPropertyName("vision")]
    public bool? Vision { get; set; }
}

/// <summary>Model capabilities and limits.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilities
{
    /// <summary>Token limits for prompts, outputs, and context window.</summary>
    [JsonPropertyName("limits")]
    public ModelCapabilitiesLimits? Limits { get; set; }

    /// <summary>Feature flags indicating what the model supports.</summary>
    [JsonPropertyName("supports")]
    public ModelCapabilitiesSupports? Supports { get; set; }
}

/// <summary>A service-published message about a model, carrying a stable machine-readable code alongside human-readable text.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelMessage
{
    /// <summary>Stable machine-readable identifier for the message, such as `client_version_deprecated`. Hosts can key custom presentation off this; unrecognized codes should fall back to displaying `message`.</summary>
    [JsonPropertyName("code")]
    public string Code { get; set; } = string.Empty;

    /// <summary>Human-readable message text intended for display to the user.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;
}

/// <summary>Policy state (if applicable).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelPolicy
{
    /// <summary>Current policy state for this model.</summary>
    [JsonPropertyName("state")]
    public ModelPolicyState State { get; set; }

    /// <summary>Usage terms or conditions for this model.</summary>
    [JsonPropertyName("terms")]
    public string? Terms { get; set; }
}

/// <summary>Service-published warning text that hosts should display when presenting a model.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelWarningText
{
    /// <summary>Data-retention warning for the model. The text may contain Markdown links and should be rendered as Markdown when supported.</summary>
    [JsonPropertyName("dataRetention")]
    public string? DataRetention { get; set; }
}

/// <summary>Copilot model metadata, including identifier, display name, capabilities, policy, billing, reasoning efforts, and picker categories.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class Model
{
    /// <summary>Billing information.</summary>
    [JsonPropertyName("billing")]
    public ModelBilling? Billing { get; set; }

    /// <summary>Model capabilities and limits.</summary>
    [JsonPropertyName("capabilities")]
    public ModelCapabilities Capabilities { get => field ??= new(); set; }

    /// <summary>Default reasoning effort level (only present if model supports reasoning effort).</summary>
    [JsonPropertyName("defaultReasoningEffort")]
    public string? DefaultReasoningEffort { get; set; }

    /// <summary>Model identifier (e.g., "claude-sonnet-4.5").</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Informational notices the service published for this model, such as an upcoming change or a recommended alternative. Present only when the service published at least one notice. Hosts should surface these without implying anything is wrong with the model.</summary>
    [JsonPropertyName("infoMessages")]
    public IList<ModelMessage>? InfoMessages { get; set; }

    /// <summary>Provider-supplied model metadata. Keys and JSON-compatible values are preserved unchanged. This is factual metadata published by the model provider; it carries no picker or UX semantics.</summary>
    [JsonPropertyName("metadata")]
    public IDictionary<string, JsonElement>? Metadata { get; set; }

    /// <summary>Model capability category for grouping in the model picker.</summary>
    [JsonPropertyName("modelPickerCategory")]
    public ModelPickerCategory? ModelPickerCategory { get; set; }

    /// <summary>Relative cost tier for token-based billing users.</summary>
    [JsonPropertyName("modelPickerPriceCategory")]
    public ModelPickerPriceCategory? ModelPickerPriceCategory { get; set; }

    /// <summary>Display name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Policy state (if applicable).</summary>
    [JsonPropertyName("policy")]
    public ModelPolicy? Policy { get; set; }

    /// <summary>Context-window tiers this model offers, when the provider advertises them independently of tiered token pricing. Copilot models carry their tiers in `billing.tokenPrices`; a provider that has no pricing to publish (an agent host reached over AHP, for example) declares them here instead, so the model picker can still offer the tier toggle.</summary>
    [JsonPropertyName("supportedContextTiers")]
    public IList<string>? SupportedContextTiers { get; set; }

    /// <summary>Supported reasoning effort levels (only present if model supports reasoning effort).</summary>
    [JsonPropertyName("supportedReasoningEfforts")]
    public IList<string>? SupportedReasoningEfforts { get; set; }

    /// <summary>Warnings the service published for this model, such as a deprecated client version. Present only when the service published at least one warning. The model remains usable; hosts should surface these as advisory rather than blocking.</summary>
    [JsonPropertyName("warningMessages")]
    public IList<ModelMessage>? WarningMessages { get; set; }

    /// <summary>Warning text the service requires hosts to surface for this model. Present only when the service published at least one warning.</summary>
    [JsonPropertyName("warningText")]
    public ModelWarningText? WarningText { get; set; }
}

/// <summary>List of Copilot models available to the resolved user, including capabilities and billing metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelList
{
    /// <summary>List of available models with full metadata.</summary>
    [JsonPropertyName("models")]
    public IList<Model> Models { get => field ??= []; set; }
}

/// <summary>RPC data type for ModelsList operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ModelsListRequest
{
    /// <summary>GitHub token accepted for compatibility with existing SDK clients. When provided, resolves this token instead of using the current account.</summary>
    [JsonPropertyName("gitHubToken")]
    public string? GitHubToken { get; set; }

    /// <summary>Opaque account identifier returned by `account.getAllUsers`. When omitted, the current account is used.</summary>
    [JsonPropertyName("selectionId")]
    public string? SelectionId { get; set; }
}

/// <summary>A well-known model in the runtime's built-in catalog.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class BuiltInModelCatalogEntry
{
    /// <summary>Well-known runtime model ID suitable for provider or provider-model metadata. This is not necessarily the provider-facing deployment or model name and does not indicate CAPI entitlement or provider availability.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;
}

/// <summary>The running runtime's complete catalog of well-known built-in model IDs, including supported models and additional IDs with built-in metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class BuiltInModelCatalog
{
    /// <summary>Built-in model entries.</summary>
    [JsonPropertyName("models")]
    public IList<BuiltInModelCatalogEntry> Models { get => field ??= []; set; }
}

/// <summary>Built-in tool metadata with identifier, optional namespaced name, description, input-parameter schema, and usage instructions.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class Tool
{
    /// <summary>Description of what the tool does.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Optional instructions for how to use this tool effectively.</summary>
    [JsonPropertyName("instructions")]
    public string? Instructions { get; set; }

    /// <summary>Tool identifier (e.g., "bash", "grep", "str_replace_editor").</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Optional namespaced name for declarative filtering (e.g., "playwright/navigate" for MCP tools).</summary>
    [JsonPropertyName("namespacedName")]
    public string? NamespacedName { get; set; }

    /// <summary>JSON Schema for the tool's input parameters.</summary>
    [JsonPropertyName("parameters")]
    public IDictionary<string, JsonElement>? Parameters { get; set; }
}

/// <summary>Built-in tools available for the requested model, with their parameters and instructions.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolList
{
    /// <summary>List of available built-in tools with metadata.</summary>
    [JsonPropertyName("tools")]
    public IList<Tool> Tools { get => field ??= []; set; }
}

/// <summary>Optional model identifier whose tool overrides should be applied to the listing.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ToolsListRequest
{
    /// <summary>Optional model ID — when provided, the returned tool list reflects model-specific overrides.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }
}

/// <summary>Quota usage snapshot for a Copilot quota type, including entitlement, used requests, overage, reset date, and remaining percentage.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AccountQuotaSnapshot
{
    /// <summary>Number of requests included in the entitlement, or -1 for unlimited entitlements.</summary>
    [JsonPropertyName("entitlementRequests")]
    public long EntitlementRequests { get; set; }

    /// <summary>Whether the user has an unlimited usage entitlement.</summary>
    [JsonPropertyName("isUnlimitedEntitlement")]
    public bool IsUnlimitedEntitlement { get; set; }

    /// <summary>Number of additional usage requests made this period.</summary>
    [JsonPropertyName("overage")]
    public double Overage { get; set; }

    /// <summary>Whether additional usage is allowed when quota is exhausted.</summary>
    [JsonPropertyName("overageAllowedWithExhaustedQuota")]
    public bool OverageAllowedWithExhaustedQuota { get; set; }

    /// <summary>Percentage of entitlement remaining.</summary>
    [JsonPropertyName("remainingPercentage")]
    public double RemainingPercentage { get; set; }

    /// <summary>Date when the quota resets (ISO 8601 string).</summary>
    [JsonPropertyName("resetDate")]
    public DateTimeOffset? ResetDate { get; set; }

    /// <summary>Whether usage is still permitted after quota exhaustion.</summary>
    [JsonPropertyName("usageAllowedWithExhaustedQuota")]
    public bool UsageAllowedWithExhaustedQuota { get; set; }

    /// <summary>Number of requests used so far this period.</summary>
    [JsonPropertyName("usedRequests")]
    public long UsedRequests { get; set; }
}

/// <summary>Quota usage snapshots for the resolved user, keyed by quota type.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AccountGetQuotaResult
{
    /// <summary>Quota snapshots keyed by type (e.g., chat, completions, premium_interactions).</summary>
    [JsonPropertyName("quotaSnapshots")]
    public IDictionary<string, AccountQuotaSnapshot> QuotaSnapshots { get => field ??= new Dictionary<string, AccountQuotaSnapshot>(); set; }
}

/// <summary>RPC data type for AccountGetQuota operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AccountGetQuotaRequest
{
    /// <summary>GitHub token accepted for compatibility with existing SDK clients. When provided, resolves this token instead of using the current account.</summary>
    [JsonPropertyName("gitHubToken")]
    public string? GitHubToken { get; set; }

    /// <summary>Opaque account identifier returned by `account.getAllUsers`. When omitted, the current account is used.</summary>
    [JsonPropertyName("selectionId")]
    public string? SelectionId { get; set; }
}

/// <summary>Authentication credentials accepted only at native protocol ingress. Runtime outputs use credential-free `AuthIdentity` metadata.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(AuthInfoHmac), "hmac")]
[JsonDerivedType(typeof(AuthInfoEnv), "env")]
[JsonDerivedType(typeof(AuthInfoToken), "token")]
[JsonDerivedType(typeof(AuthInfoTokenProvider), "token-provider")]
[JsonDerivedType(typeof(AuthInfoCopilotApiToken), "copilot-api-token")]
[JsonDerivedType(typeof(AuthInfoUser), "user")]
[JsonDerivedType(typeof(AuthInfoGhCli), "gh-cli")]
[JsonDerivedType(typeof(AuthInfoApiKey), "api-key")]
public partial class AuthInfo
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>Endpoint URLs from the raw Copilot `/copilot_internal/v2/token` user-response passthrough.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CopilotUserResponseEndpoints
{
    /// <summary>Copilot API endpoint URL.</summary>
    [JsonPropertyName("api")]
    public string? Api { get; set; }

    /// <summary>Experimental-service endpoint URL.</summary>
    [JsonPropertyName("exp")]
    public string? Exp { get; set; }

    /// <summary>Origin-tracker endpoint URL.</summary>
    [JsonPropertyName("origin-tracker")]
    public string? OriginTracker { get; set; }

    /// <summary>Copilot proxy endpoint URL.</summary>
    [JsonPropertyName("proxy")]
    public string? Proxy { get; set; }

    /// <summary>Copilot telemetry endpoint URL.</summary>
    [JsonPropertyName("telemetry")]
    public string? Telemetry { get; set; }
}

/// <summary>RPC data type for CopilotUserResponseOrganizationListItem operations.</summary>
public sealed class CopilotUserResponseOrganizationListItem
{
    /// <summary>GitHub login of the organization.</summary>
    [JsonPropertyName("login")]
    public string? Login { get; set; }

    /// <summary>Display name of the organization.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }
}

/// <summary>Chat quota snapshot from the raw Copilot user-response passthrough, with entitlement, overage, remaining quota, reset, and billing fields.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CopilotUserResponseQuotaSnapshotsChat
{
    /// <summary>Number of requests/units included in the entitlement for this period; `-1` denotes an unlimited entitlement.</summary>
    [JsonPropertyName("entitlement")]
    public double? Entitlement { get; set; }

    /// <summary>Whether the user currently has quota available; when `false` and not unlimited, further requests are blocked until the quota resets.</summary>
    [JsonPropertyName("has_quota")]
    public bool? HasQuota { get; set; }

    /// <summary>Count of additional pay-per-request usage consumed this period beyond the entitlement.</summary>
    [JsonPropertyName("overage_count")]
    public double? OverageCount { get; set; }

    /// <summary>Whether usage may continue at pay-per-request rates once the entitlement is exhausted.</summary>
    [JsonPropertyName("overage_permitted")]
    public bool? OveragePermitted { get; set; }

    /// <summary>Percentage of the entitlement remaining at the snapshot timestamp.</summary>
    [JsonPropertyName("percent_remaining")]
    public double? PercentRemaining { get; set; }

    /// <summary>Identifier of the quota bucket this snapshot describes.</summary>
    [JsonPropertyName("quota_id")]
    public string? QuotaId { get; set; }

    /// <summary>Amount of quota remaining at the snapshot timestamp.</summary>
    [JsonPropertyName("quota_remaining")]
    public double? QuotaRemaining { get; set; }

    /// <summary>Unix epoch time, in seconds, when this quota next resets.</summary>
    [JsonPropertyName("quota_reset_at")]
    public double? QuotaResetAt { get; set; }

    /// <summary>Remaining entitlement/quota amount at the snapshot timestamp.</summary>
    [JsonPropertyName("remaining")]
    public double? Remaining { get; set; }

    /// <summary>UTC timestamp when this snapshot was captured.</summary>
    [JsonPropertyName("timestamp_utc")]
    public string? TimestampUtc { get; set; }

    /// <summary>Whether this category uses usage-based (token/AI-credit) billing rather than a fixed premium-request count.</summary>
    [JsonPropertyName("token_based_billing")]
    public bool? TokenBasedBilling { get; set; }

    /// <summary>Whether the entitlement for this category is unlimited.</summary>
    [JsonPropertyName("unlimited")]
    public bool? Unlimited { get; set; }
}

/// <summary>Completions quota snapshot from the raw Copilot user-response passthrough, with entitlement, overage, remaining quota, reset, and billing fields.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CopilotUserResponseQuotaSnapshotsCompletions
{
    /// <summary>Number of requests/units included in the entitlement for this period; `-1` denotes an unlimited entitlement.</summary>
    [JsonPropertyName("entitlement")]
    public double? Entitlement { get; set; }

    /// <summary>Whether the user currently has quota available; when `false` and not unlimited, further requests are blocked until the quota resets.</summary>
    [JsonPropertyName("has_quota")]
    public bool? HasQuota { get; set; }

    /// <summary>Count of additional pay-per-request usage consumed this period beyond the entitlement.</summary>
    [JsonPropertyName("overage_count")]
    public double? OverageCount { get; set; }

    /// <summary>Whether usage may continue at pay-per-request rates once the entitlement is exhausted.</summary>
    [JsonPropertyName("overage_permitted")]
    public bool? OveragePermitted { get; set; }

    /// <summary>Percentage of the entitlement remaining at the snapshot timestamp.</summary>
    [JsonPropertyName("percent_remaining")]
    public double? PercentRemaining { get; set; }

    /// <summary>Identifier of the quota bucket this snapshot describes.</summary>
    [JsonPropertyName("quota_id")]
    public string? QuotaId { get; set; }

    /// <summary>Amount of quota remaining at the snapshot timestamp.</summary>
    [JsonPropertyName("quota_remaining")]
    public double? QuotaRemaining { get; set; }

    /// <summary>Unix epoch time, in seconds, when this quota next resets.</summary>
    [JsonPropertyName("quota_reset_at")]
    public double? QuotaResetAt { get; set; }

    /// <summary>Remaining entitlement/quota amount at the snapshot timestamp.</summary>
    [JsonPropertyName("remaining")]
    public double? Remaining { get; set; }

    /// <summary>UTC timestamp when this snapshot was captured.</summary>
    [JsonPropertyName("timestamp_utc")]
    public string? TimestampUtc { get; set; }

    /// <summary>Whether this category uses usage-based (token/AI-credit) billing rather than a fixed premium-request count.</summary>
    [JsonPropertyName("token_based_billing")]
    public bool? TokenBasedBilling { get; set; }

    /// <summary>Whether the entitlement for this category is unlimited.</summary>
    [JsonPropertyName("unlimited")]
    public bool? Unlimited { get; set; }
}

/// <summary>Premium-interactions quota snapshot from the raw Copilot user-response passthrough, with entitlement, overage, remaining quota, reset, and billing fields.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CopilotUserResponseQuotaSnapshotsPremiumInteractions
{
    /// <summary>Number of requests/units included in the entitlement for this period; `-1` denotes an unlimited entitlement.</summary>
    [JsonPropertyName("entitlement")]
    public double? Entitlement { get; set; }

    /// <summary>Whether the user currently has quota available; when `false` and not unlimited, further requests are blocked until the quota resets.</summary>
    [JsonPropertyName("has_quota")]
    public bool? HasQuota { get; set; }

    /// <summary>Count of additional pay-per-request usage consumed this period beyond the entitlement.</summary>
    [JsonPropertyName("overage_count")]
    public double? OverageCount { get; set; }

    /// <summary>Whether usage may continue at pay-per-request rates once the entitlement is exhausted.</summary>
    [JsonPropertyName("overage_permitted")]
    public bool? OveragePermitted { get; set; }

    /// <summary>Percentage of the entitlement remaining at the snapshot timestamp.</summary>
    [JsonPropertyName("percent_remaining")]
    public double? PercentRemaining { get; set; }

    /// <summary>Identifier of the quota bucket this snapshot describes.</summary>
    [JsonPropertyName("quota_id")]
    public string? QuotaId { get; set; }

    /// <summary>Amount of quota remaining at the snapshot timestamp.</summary>
    [JsonPropertyName("quota_remaining")]
    public double? QuotaRemaining { get; set; }

    /// <summary>Unix epoch time, in seconds, when this quota next resets.</summary>
    [JsonPropertyName("quota_reset_at")]
    public double? QuotaResetAt { get; set; }

    /// <summary>Remaining entitlement/quota amount at the snapshot timestamp.</summary>
    [JsonPropertyName("remaining")]
    public double? Remaining { get; set; }

    /// <summary>UTC timestamp when this snapshot was captured.</summary>
    [JsonPropertyName("timestamp_utc")]
    public string? TimestampUtc { get; set; }

    /// <summary>Whether this category uses usage-based (token/AI-credit) billing rather than a fixed premium-request count.</summary>
    [JsonPropertyName("token_based_billing")]
    public bool? TokenBasedBilling { get; set; }

    /// <summary>Whether the entitlement for this category is unlimited.</summary>
    [JsonPropertyName("unlimited")]
    public bool? Unlimited { get; set; }
}

/// <summary>Quota snapshot map from the raw Copilot user-response passthrough, with chat, completions, premium-interactions, and other entries.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CopilotUserResponseQuotaSnapshots
{
    /// <summary>Chat quota snapshot from the raw Copilot user-response passthrough, with entitlement, overage, remaining quota, reset, and billing fields.</summary>
    [JsonPropertyName("chat")]
    public CopilotUserResponseQuotaSnapshotsChat? Chat { get; set; }

    /// <summary>Completions quota snapshot from the raw Copilot user-response passthrough, with entitlement, overage, remaining quota, reset, and billing fields.</summary>
    [JsonPropertyName("completions")]
    public CopilotUserResponseQuotaSnapshotsCompletions? Completions { get; set; }

    /// <summary>Premium-interactions quota snapshot from the raw Copilot user-response passthrough, with entitlement, overage, remaining quota, reset, and billing fields.</summary>
    [JsonPropertyName("premium_interactions")]
    public CopilotUserResponseQuotaSnapshotsPremiumInteractions? PremiumInteractions { get; set; }
}

/// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CopilotUserResponse
{
    /// <summary>Copilot access SKU identifier (e.g. `free_limited_copilot`, `copilot_for_business_seat_quota`) used to gate model and feature access.</summary>
    [JsonPropertyName("access_type_sku")]
    public string? AccessTypeSku { get; set; }

    /// <summary>Opaque analytics tracking identifier for the user, forwarded from the Copilot API.</summary>
    [JsonPropertyName("analytics_tracking_id")]
    public string? AnalyticsTrackingId { get; set; }

    /// <summary>Date the Copilot seat was assigned to the user, if applicable.</summary>
    [JsonPropertyName("assigned_date")]
    public string? AssignedDate { get; set; }

    /// <summary>Whether the user is eligible to sign up for the free/limited Copilot tier.</summary>
    [JsonPropertyName("can_signup_for_limited")]
    public bool? CanSignupForLimited { get; set; }

    /// <summary>Whether the user is able to upgrade their Copilot plan.</summary>
    [JsonPropertyName("can_upgrade_plan")]
    public bool? CanUpgradePlan { get; set; }

    /// <summary>Whether Copilot chat is enabled for the user.</summary>
    [JsonPropertyName("chat_enabled")]
    public bool? ChatEnabled { get; set; }

    /// <summary>Whether CLI remote control is enabled for the user.</summary>
    [JsonPropertyName("cli_remote_control_enabled")]
    public bool? CliRemoteControlEnabled { get; set; }

    /// <summary>Whether cloud session storage is enabled for the user.</summary>
    [JsonPropertyName("cloud_session_storage_enabled")]
    public bool? CloudSessionStorageEnabled { get; set; }

    /// <summary>Whether the Codex agent is enabled for the user.</summary>
    [JsonPropertyName("codex_agent_enabled")]
    public bool? CodexAgentEnabled { get; set; }

    /// <summary>Copilot plan name for the user (e.g. `individual`, `business`, `enterprise`).</summary>
    [JsonPropertyName("copilot_plan")]
    public string? CopilotPlan { get; set; }

    /// <summary>Whether `.copilotignore` content-exclusion support is enabled for the user.</summary>
    [JsonPropertyName("copilotignore_enabled")]
    public bool? CopilotignoreEnabled { get; set; }

    /// <summary>Endpoint URLs from the raw Copilot `/copilot_internal/v2/token` user-response passthrough.</summary>
    [JsonPropertyName("endpoints")]
    public CopilotUserResponseEndpoints? Endpoints { get; set; }

    /// <summary>Whether MCP (Model Context Protocol) support is enabled for the user.</summary>
    [JsonPropertyName("is_mcp_enabled")]
    public bool? IsMcpEnabled { get; set; }

    /// <summary>Whether the user is a GitHub/Microsoft staff member.</summary>
    [JsonPropertyName("is_staff")]
    public bool? IsStaff { get; set; }

    /// <summary>Per-category quota allotments for free/limited-tier users, keyed by quota category.</summary>
    [JsonPropertyName("limited_user_quotas")]
    public IDictionary<string, double>? LimitedUserQuotas { get; set; }

    /// <summary>Date the free/limited-tier user's quotas next reset, as a raw string from the Copilot API.</summary>
    [JsonPropertyName("limited_user_reset_date")]
    public string? LimitedUserResetDate { get; set; }

    /// <summary>GitHub login of the authenticated user.</summary>
    [JsonPropertyName("login")]
    public string? Login { get; set; }

    /// <summary>Per-category monthly quota allotments, keyed by quota category.</summary>
    [JsonPropertyName("monthly_quotas")]
    public IDictionary<string, double>? MonthlyQuotas { get; set; }

    /// <summary>Organizations the user belongs to, each with an optional login and display name.</summary>
    [JsonPropertyName("organization_list")]
    public IList<CopilotUserResponseOrganizationListItem?>? OrganizationList { get; set; }

    /// <summary>Logins of the organizations the user belongs to.</summary>
    [JsonPropertyName("organization_login_list")]
    public IList<string>? OrganizationLoginList { get; set; }

    /// <summary>Date the user's usage quota next resets, as a raw string from the Copilot API; see `quota_reset_date_utc` for the UTC-normalized value.</summary>
    [JsonPropertyName("quota_reset_date")]
    public string? QuotaResetDate { get; set; }

    /// <summary>UTC-normalized form of `quota_reset_date` (the date the user's usage quota next resets).</summary>
    [JsonPropertyName("quota_reset_date_utc")]
    public string? QuotaResetDateUtc { get; set; }

    /// <summary>Quota snapshot map from the raw Copilot user-response passthrough, with chat, completions, premium-interactions, and other entries.</summary>
    [JsonPropertyName("quota_snapshots")]
    public CopilotUserResponseQuotaSnapshots? QuotaSnapshots { get; set; }

    /// <summary>Whether the user's telemetry is subject to restricted-data handling.</summary>
    [JsonPropertyName("restricted_telemetry")]
    public bool? RestrictedTelemetry { get; set; }

    /// <summary>Raw passthrough of the Copilot API `te` flag for the user (an opaque server-side eligibility signal surfaced in telemetry); not otherwise interpreted by the runtime.</summary>
    [JsonPropertyName("te")]
    public bool? Te { get; set; }

    /// <summary>Whether the account is on usage-based (token/AI-credit) billing rather than a fixed premium-request quota.</summary>
    [JsonPropertyName("token_based_billing")]
    public bool? TokenBasedBilling { get; set; }
}

/// <summary>Authentication-info input variant for GitHub-internal HMAC auth, carrying the public GitHub host and HMAC secret.</summary>
/// <remarks>The <c>hmac</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoHmac : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "hmac";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>HMAC secret used to sign requests.</summary>
    [JsonPropertyName("hmac")]
    public required string Hmac { get; set; }

    /// <summary>Authentication host. HMAC auth always targets the public GitHub host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }
}

/// <summary>Authentication-info input variant for a token sourced from an environment variable, with host, optional login, token, and env var name.</summary>
/// <remarks>The <c>env</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoEnv : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "env";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Name of the environment variable the token was sourced from.</summary>
    [JsonPropertyName("envVar")]
    public required string EnvVar { get; set; }

    /// <summary>Authentication host (e.g. https://github.com or a GHES host).</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>User login associated with the token. Undefined for server-to-server tokens (those starting with `ghs_`).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("login")]
    public string? Login { get; set; }

    /// <summary>The token value itself. Treat as a secret.</summary>
    [JsonPropertyName("token")]
    public required string Token { get; set; }
}

/// <summary>Authentication-info input variant for SDK-configured token authentication, carrying host and the secret token value.</summary>
/// <remarks>The <c>token</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoToken : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "token";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>Opaque native GitHub credential registration backing this token identity, when applicable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("registrationId")]
    public string? RegistrationId { get; set; }

    /// <summary>The token value itself. Treat as a secret.</summary>
    [JsonPropertyName("token")]
    public required string Token { get; set; }
}

/// <summary>Authentication-info variant backed by an SDK GitHub token callback. It carries routing metadata but never a plaintext token.</summary>
/// <remarks>The <c>token-provider</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoTokenProvider : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "token-provider";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>Opaque SDK callback registration identifier.</summary>
    [JsonPropertyName("registrationId")]
    public required string RegistrationId { get; set; }
}

/// <summary>Authentication-info variant for direct Copilot API token auth sourced from environment variables, with public GitHub host.</summary>
/// <remarks>The <c>copilot-api-token</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoCopilotApiToken : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "copilot-api-token";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host (always the public GitHub host).</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }
}

/// <summary>Authentication-info variant for OAuth user auth, with host and login; the token remains in the runtime secret store.</summary>
/// <remarks>The <c>user</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoUser : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "user";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>OAuth user login.</summary>
    [JsonPropertyName("login")]
    public required string Login { get; set; }
}

/// <summary>Authentication-info input variant for GitHub CLI credentials, carrying host, login, and the `gh auth token` value.</summary>
/// <remarks>The <c>gh-cli</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoGhCli : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "gh-cli";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>User login as reported by `gh auth status`.</summary>
    [JsonPropertyName("login")]
    public required string Login { get; set; }

    /// <summary>The token returned by `gh auth token`. Treat as a secret.</summary>
    [JsonPropertyName("token")]
    public required string Token { get; set; }
}

/// <summary>Authentication-info input variant for API-key authentication to a non-GitHub LLM provider, carrying the secret `apiKey` and host.</summary>
/// <remarks>The <c>api-key</c> variant of <see cref="AuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AuthInfoApiKey : AuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "api-key";

    /// <summary>The API key. Treat as a secret.</summary>
    [JsonPropertyName("apiKey")]
    public required string ApiKey { get; set; }

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }
}

/// <summary>Current authentication state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AccountGetCurrentAuthResult
{
    /// <summary>Authentication errors from the last auth attempt, if any.</summary>
    [JsonPropertyName("authErrors")]
    public IList<string>? AuthErrors { get; set; }

    /// <summary>Current authentication information, if authenticated.</summary>
    [JsonPropertyName("authInfo")]
    public AuthInfo? AuthInfo { get; set; }
}

/// <summary>Authenticated account entry returned by `account.getAllUsers`.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AccountAllUsers
{
    /// <summary>Authentication information for this user.</summary>
    [JsonPropertyName("authInfo")]
    public AuthInfo AuthInfo { get => field ??= new(); set; }

    /// <summary>Opaque identifier accepted by account and model selection APIs.</summary>
    [JsonPropertyName("selectionId")]
    public string? SelectionId { get; set; }

    /// <summary>Associated token, if available.</summary>
    [JsonPropertyName("token")]
    public string? Token { get; set; }
}

/// <summary>Result of a successful login; throws on failure.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AccountLoginResult
{
    /// <summary>Whether the credential was persisted to a secure store (system keychain, or the config file when plaintext storage is enabled). False when no secure store was available and the token was not saved, so the consumer can decide how to proceed.</summary>
    [JsonPropertyName("storedInVault")]
    public bool StoredInVault { get; set; }
}

/// <summary>Credentials to validate and store. Omit login to resolve the authenticated user from the token.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AccountLoginRequest
{
    /// <summary>GitHub host URL.</summary>
    [JsonPropertyName("host")]
    public string Host { get; set; } = string.Empty;

    /// <summary>User login/username. When omitted, the runtime validates the token and resolves the login from GitHub.</summary>
    [JsonPropertyName("login")]
    public string? Login { get; set; }

    /// <summary>GitHub authentication token.</summary>
    [JsonPropertyName("token")]
    public string Token { get; set; } = string.Empty;
}

/// <summary>Logout result indicating if more users remain.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AccountLogoutResult
{
    /// <summary>Whether other authenticated users remain after logout.</summary>
    [JsonPropertyName("hasMoreUsers")]
    public bool HasMoreUsers { get; set; }
}

/// <summary>User to log out.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AccountLogoutRequest
{
    /// <summary>Authentication information for the user to log out.</summary>
    [JsonPropertyName("authInfo")]
    public AuthInfo? AuthInfo { get; set; }

    /// <summary>Opaque account identifier returned by `account.getAllUsers`.</summary>
    [JsonPropertyName("selectionId")]
    public string? SelectionId { get; set; }
}

/// <summary>Confirmation that the secret values were registered.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SecretsAddFilterValuesResult
{
    /// <summary>Whether the values were successfully registered.</summary>
    [JsonPropertyName("ok")]
    public bool Ok { get; set; }
}

/// <summary>Secret values to add to the redaction filter.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SecretsAddFilterValuesRequest
{
    /// <summary>Raw secret values to register for redaction.</summary>
    [JsonPropertyName("values")]
    public IList<string> Values { get => field ??= []; set; }
}

/// <summary>Concrete configuration file containing an MCP server declaration.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpSourceFile
{
    /// <summary>RFC 6901 JSON Pointer to the server declaration, when known.</summary>
    [JsonPropertyName("jsonPointer")]
    public string? JsonPointer { get; set; }

    /// <summary>Canonical file URI for the configuration document.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("uri")]
    public string Uri { get; set; } = string.Empty;
}

/// <summary>Plugin identity associated with an MCP server declaration.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpSourcePlugin
{
    /// <summary>Canonical plugin identity.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Human-readable plugin name, when available.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Plugin version, when available.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("version")]
    public string? Version { get; set; }
}

/// <summary>Canonical identity and location of the effective MCP server declaration. The declaration is uniquely addressed by this source id together with the discovered server name.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpSourceRef
{
    /// <summary>Open semantic editability identifier. Known values are editable and read-only.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("editability")]
    public string Editability { get; set; } = string.Empty;

    /// <summary>Configuration file location, when the declaration is file-backed.</summary>
    [JsonPropertyName("file")]
    public McpSourceFile? File { get; set; }

    /// <summary>Opaque stable identity for the configuration source. Clients must not parse this value.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Open source-kind identifier. Known values include user, workspace, invocation, plugin, builtin, and device-registry.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("kind")]
    public string Kind { get; set; } = string.Empty;

    /// <summary>Plugin identity, when the declaration is plugin-provided.</summary>
    [JsonPropertyName("plugin")]
    public McpSourcePlugin? Plugin { get; set; }
}

/// <summary>MCP server discovered by `mcp.discover`, with config source, optional plugin source, transport type, and enabled state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DiscoveredMcpServer
{
    /// <summary>Canonical identity and location of the effective server declaration.</summary>
    [JsonPropertyName("effectiveSource")]
    public McpSourceRef? EffectiveSource { get; set; }

    /// <summary>Whether the server is enabled (not in the disabled list).</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Server name (config key).</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Configuration source: user, workspace, plugin, or builtin.</summary>
    [JsonPropertyName("source")]
    public McpServerSource Source { get; set; }

    /// <summary>Plugin name that provided this server, when source is plugin.</summary>
    [JsonPropertyName("sourcePlugin")]
    public string? SourcePlugin { get; set; }

    /// <summary>Plugin version that provided this server, when source is plugin.</summary>
    [JsonPropertyName("sourcePluginVersion")]
    public string? SourcePluginVersion { get; set; }

    /// <summary>Server transport type: stdio, http, sse (deprecated), or memory.</summary>
    [JsonPropertyName("type")]
    public DiscoveredMcpServerType? Type { get; set; }
}

/// <summary>MCP servers discovered from user, workspace, plugin, and built-in sources.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpDiscoverResult
{
    /// <summary>MCP servers discovered from all sources.</summary>
    [JsonPropertyName("servers")]
    public IList<DiscoveredMcpServer> Servers { get => field ??= []; set; }
}

/// <summary>Optional working directory used as context for MCP server discovery.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpDiscoverRequest
{
    /// <summary>Whether to include canonical effectiveSource metadata for each discovered server. Callers must opt in so protocol-3 clients retain the legacy closed response shape.</summary>
    [JsonPropertyName("includeEffectiveSource")]
    public bool? IncludeEffectiveSource { get; set; }

    /// <summary>Working directory used as context for discovery (e.g., plugin resolution).</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Outcome of an mcp.planInstall call: either a normalised plan, or one typed refusal. Nothing is written in either case.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpPlanInstallResultPlanned), "planned")]
[JsonDerivedType(typeof(McpPlanInstallResultNegotiationRefused), "negotiation-refused")]
[JsonDerivedType(typeof(McpPlanInstallResultHandleRejected), "handle-rejected")]
[JsonDerivedType(typeof(McpPlanInstallResultInvalidRequest), "invalid-request")]
[JsonDerivedType(typeof(McpPlanInstallResultAuthenticationRequired), "authentication-required")]
[JsonDerivedType(typeof(McpPlanInstallResultPolicyRejected), "policy-rejected")]
[JsonDerivedType(typeof(McpPlanInstallResultNetworkFailure), "network-failure")]
[JsonDerivedType(typeof(McpPlanInstallResultUnsafeRetrieval), "unsafe-retrieval")]
[JsonDerivedType(typeof(McpPlanInstallResultMalformedCard), "malformed-card")]
[JsonDerivedType(typeof(McpPlanInstallResultContractViolation), "contract-violation")]
[JsonDerivedType(typeof(McpPlanInstallResultUnavailableTransport), "unavailable-transport")]
[JsonDerivedType(typeof(McpPlanInstallResultNotInstallable), "not-installable")]
[JsonDerivedType(typeof(McpPlanInstallResultUnavailable), "unavailable")]
public partial class McpPlanInstallResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>The protocol version and capability set the runtime actually honoured for a successful catalog operation.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CatalogNegotiatedContract
{
    /// <summary>Wire features the runtime understood for this operation. Always a superset of the caller's required features, because any shortfall is a refusal instead. Operation availability remains a separate typed result.</summary>
    [JsonPropertyName("grantedCapabilities")]
    public IList<CatalogCapability> GrantedCapabilities { get => field ??= []; set; }

    /// <summary>Protocol version of the runtime that served the request.</summary>
    [JsonPropertyName("runtimeProtocolVersion")]
    public long RuntimeProtocolVersion { get; set; }
}

/// <summary>One change applying the plan would make, described rather than serialised so the configuration payload stays behind the runtime boundary.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpPlanConfigurationChange
{
    /// <summary>Names of the configuration fields the change would set, without their values.</summary>
    [JsonPropertyName("changedFields")]
    public IList<string> ChangedFields { get => field ??= []; set; }

    /// <summary>Configuration key the change applies to.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("configKey")]
    public string ConfigKey { get; set; } = string.Empty;

    /// <summary>Whether the change would create a new entry or modify an existing one.</summary>
    [JsonPropertyName("operation")]
    public McpPlanConfigurationOperation Operation { get; set; }

    /// <summary>Scope the change would be written to.</summary>
    [JsonPropertyName("scope")]
    public McpPlanScope Scope { get; set; }

    /// <summary>Secret placeholders the written configuration would reference. The constrained placeholder type cannot carry a literal secret value.</summary>
    [JsonPropertyName("secretReferences")]
    public IList<string> SecretReferences { get => field ??= []; set; }
}

/// <summary>Normalised identity of the MCP server a plan targets, independent of how the card spelled it.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpPlanResourceIdentity
{
    /// <summary>Canonical, normalised name of the server, for example `io.github.owner/server`.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("canonicalName")]
    public string CanonicalName { get; set; } = string.Empty;

    /// <summary>Registry identifier of the server, when it came from a registry.</summary>
    [JsonPropertyName("registryId")]
    public string? RegistryId { get; set; }

    /// <summary>Local configuration key the server would be recorded under.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Version advertised by the card, when it declares one.</summary>
    [JsonPropertyName("version")]
    public string? Version { get; set; }
}

/// <summary>Outcome of evaluating the planned server against registry and enterprise policy. Evaluation is read-only.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpPlanPolicyResult
{
    /// <summary>What policy decided for this server.</summary>
    [JsonPropertyName("decision")]
    public McpPlanPolicyDecision Decision { get; set; }

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Which authority produced the decision.</summary>
    [JsonPropertyName("source")]
    public McpPlanPolicySource Source { get; set; }
}

/// <summary>Semantic digest of a strictly parsed and schema-validated JSON MCP card. Both URL-backed and embedded cards are canonicalised with RFC 8785 JSON Canonicalization Scheme, encoded as UTF-8, and hashed with SHA-256.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CardDigest
{
    /// <summary>Digest algorithm and canonical representation.</summary>
    [JsonPropertyName("algorithm")]
    public CardDigestAlgorithm Algorithm { get; set; }

    /// <summary>SHA-256 digest of the RFC 8785 canonical UTF-8 bytes, encoded as exactly 64 lowercase hexadecimal characters.</summary>
    [RegularExpression("^[0-9a-f]{64}$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(64)]
    [MaxLength(64)]
    [JsonPropertyName("value")]
    public string Value { get; set; } = string.Empty;
}

/// <summary>Provenance of the exact validated JSON MCP card content bound privately to a completed plan and its opaque handle.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpPlanProvenance
{
    /// <summary>Authority associated with the validated card, without path, query, or credentials. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("authority")]
    public string Authority { get; set; } = string.Empty;

    /// <summary>Semantic digest of the exact validated JSON content bound to the plan handle.</summary>
    [JsonPropertyName("cardDigest")]
    public CardDigest CardDigest { get => field ??= new(); set; }

    /// <summary>JSON MCP media type the validated card was interpreted as.</summary>
    [JsonPropertyName("mediaType")]
    public McpServerCardMediaType MediaType { get; set; }

    /// <summary>ISO 8601 timestamp at which the runtime completed strict parsing and schema validation of the card content.</summary>
    [JsonPropertyName("validatedAt")]
    public string ValidatedAt { get; set; } = string.Empty;
}

/// <summary>Where a plan would be written.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpPlanTarget
{
    /// <summary>Configuration key the server would be recorded under within that scope.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("configKey")]
    public string ConfigKey { get; set; } = string.Empty;

    /// <summary>Configuration scope the plan targets.</summary>
    [JsonPropertyName("scope")]
    public McpPlanScope Scope { get; set; }
}

/// <summary>One eligible way to run the server, represented as a tagged package or remote variant so package identity and endpoint states cannot contradict the install method.</summary>
/// <remarks>Polymorphic base type discriminated by <c>installMethod</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "installMethod",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpPlanTransportChoicePackage), "package")]
[JsonDerivedType(typeof(McpPlanTransportChoiceRemote), "remote")]
public partial class McpPlanTransportChoice
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("installMethod")]
    public virtual string InstallMethod { get; set; } = string.Empty;
}


/// <summary>One non-secret value a transport choice needs, represented as a scalar or enumerated variant so enum values cannot be missing or attached to another type.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpPlanRequiredValueScalar), "scalar")]
[JsonDerivedType(typeof(McpPlanRequiredValueEnum), "enum")]
public partial class McpPlanRequiredValue
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>One non-secret scalar value a transport choice needs before it can be applied.</summary>
/// <remarks>The <c>scalar</c> variant of <see cref="McpPlanRequiredValue"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanRequiredValueScalar : McpPlanRequiredValue
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "scalar";

    /// <summary>Where the value is applied when the server is launched.</summary>
    [JsonPropertyName("category")]
    public required McpPlanValueCategory Category { get; set; }

    /// <summary>Default supplied by the card, when the value can be resolved without input. Presence is the authoritative indication that a default exists. Inert untrusted data.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("defaultValue")]
    public string? DefaultValue { get; set; }

    /// <summary>Human-readable explanation from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Whether the value may be supplied more than once.</summary>
    [JsonPropertyName("isRepeated")]
    public required bool IsRepeated { get; set; }

    /// <summary>Key the value is supplied under. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("key")]
    public required string Key { get; set; }

    /// <summary>Whether the value must be present for the plan to be applicable.</summary>
    [JsonPropertyName("required")]
    public required bool Required { get; set; }

    /// <summary>Human-readable label from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(200)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>Scalar type the value must conform to.</summary>
    [JsonPropertyName("valueType")]
    public required McpPlanScalarValueType ValueType { get; set; }
}

/// <summary>One enumerated non-secret value a transport choice needs before it can be applied. The permitted values are structurally required.</summary>
/// <remarks>The <c>enum</c> variant of <see cref="McpPlanRequiredValue"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanRequiredValueEnum : McpPlanRequiredValue
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "enum";

    /// <summary>Where the value is applied when the server is launched.</summary>
    [JsonPropertyName("category")]
    public required McpPlanValueCategory Category { get; set; }

    /// <summary>Default supplied by the card, when the value can be resolved without input. Presence is the authoritative indication that a default exists. Inert untrusted data.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("defaultValue")]
    public string? DefaultValue { get; set; }

    /// <summary>Human-readable explanation from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Non-empty permitted value set. Inert untrusted data.</summary>
    [JsonPropertyName("enumValues")]
    public required IList<string> EnumValues { get; set; }

    /// <summary>Whether the value may be supplied more than once.</summary>
    [JsonPropertyName("isRepeated")]
    public required bool IsRepeated { get; set; }

    /// <summary>Key the value is supplied under. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("key")]
    public required string Key { get; set; }

    /// <summary>Whether the value must be present for the plan to be applicable.</summary>
    [JsonPropertyName("required")]
    public required bool Required { get; set; }

    /// <summary>Human-readable label from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(200)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>Discriminator: the value must be one of `enumValues`.</summary>
    [JsonPropertyName("valueType")]
    public required McpPlanEnumValueType ValueType { get; set; }
}

/// <summary>A secret a transport choice needs, referenced by placeholder. No secret value ever appears in a plan, and the placeholder resolves against the keychain only when a plan is applied.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpPlanSecretPlaceholder
{
    /// <summary>Key the secret is supplied under. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("key")]
    public string Key { get; set; } = string.Empty;

    /// <summary>The runtime-assigned `${secret:&lt;id&gt;}` placeholder written into configuration in place of the value.</summary>
    [JsonPropertyName("placeholder")]
    public string Placeholder { get; set; } = string.Empty;

    /// <summary>Human-readable label from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(200)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }
}

/// <summary>An eligible local-package transport choice. Package identity is required and a remote endpoint cannot be represented.</summary>
/// <remarks>The <c>package</c> variant of <see cref="McpPlanTransportChoice"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanTransportChoicePackage : McpPlanTransportChoice
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string InstallMethod => "package";

    /// <summary>Stable identifier for this choice within the plan, used to select it when the plan is applied.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(128)]
    [JsonPropertyName("choiceId")]
    public required string ChoiceId { get; set; }

    /// <summary>Package identifier. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(512)]
    [JsonPropertyName("packageIdentifier")]
    public required string PackageIdentifier { get; set; }

    /// <summary>Packaging ecosystem, for example `oci` or `npm`.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(64)]
    [JsonPropertyName("packageType")]
    public required string PackageType { get; set; }

    /// <summary>Typed values this choice requires, excluding secrets.</summary>
    [JsonPropertyName("requiredValues")]
    public required IList<McpPlanRequiredValue> RequiredValues { get; set; }

    /// <summary>Secrets this choice requires, referenced by placeholder only.</summary>
    [JsonPropertyName("secretPlaceholders")]
    public required IList<McpPlanSecretPlaceholder> SecretPlaceholders { get; set; }

    /// <summary>Local process transport this package choice would use.</summary>
    [JsonPropertyName("transport")]
    public required McpPlanPackageTransport Transport { get; set; }
}

/// <summary>An eligible remote-endpoint transport choice. The endpoint is required and package identity cannot be represented.</summary>
/// <remarks>The <c>remote</c> variant of <see cref="McpPlanTransportChoice"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanTransportChoiceRemote : McpPlanTransportChoice
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string InstallMethod => "remote";

    /// <summary>Stable identifier for this choice within the plan, used to select it when the plan is applied.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(128)]
    [JsonPropertyName("choiceId")]
    public required string ChoiceId { get; set; }

    /// <summary>Endpoint URL. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(2048)]
    [JsonPropertyName("endpoint")]
    public required string Endpoint { get; set; }

    /// <summary>Typed values this choice requires, excluding secrets.</summary>
    [JsonPropertyName("requiredValues")]
    public required IList<McpPlanRequiredValue> RequiredValues { get; set; }

    /// <summary>Secrets this choice requires, referenced by placeholder only.</summary>
    [JsonPropertyName("secretPlaceholders")]
    public required IList<McpPlanSecretPlaceholder> SecretPlaceholders { get; set; }

    /// <summary>Endpoint transport this remote choice would use.</summary>
    [JsonPropertyName("transport")]
    public required McpPlanRemoteTransport Transport { get; set; }
}

/// <summary>A normalised, inert description of what installing an MCP server would involve. Carries no raw card, no install specification, and no secret value.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpInstallPlan
{
    /// <summary>The configuration changes installing would make, described rather than serialised, so the mutable configuration payload stays behind the runtime boundary.</summary>
    [JsonPropertyName("configurationChanges")]
    public IList<McpPlanConfigurationChange> ConfigurationChanges { get => field ??= []; set; }

    /// <summary>Normalised identity of the server the plan would install.</summary>
    [JsonPropertyName("identity")]
    public McpPlanResourceIdentity Identity { get => field ??= new(); set; }

    /// <summary>Opaque, runtime-instance scoped, TTL-bound, single-use handle for this plan. Rejected when stale, replayed, or presented to a different runtime instance. Never logged.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("planHandle")]
    public string PlanHandle { get; set; } = string.Empty;

    /// <summary>ISO 8601 timestamp after which the plan handle is stale and will be rejected. Abandoning a plan needs no call: an unused handle simply expires, so cancellation before commit is side-effect free.</summary>
    [JsonPropertyName("planHandleExpiresAt")]
    public string PlanHandleExpiresAt { get; set; } = string.Empty;

    /// <summary>Outcome of evaluating the server against registry and enterprise policy.</summary>
    [JsonPropertyName("policy")]
    public McpPlanPolicyResult Policy { get => field ??= new(); set; }

    /// <summary>Origin and semantic digest of the exact validated JSON MCP card content bound to this plan.</summary>
    [JsonPropertyName("provenance")]
    public McpPlanProvenance Provenance { get => field ??= new(); set; }

    /// <summary>Identifier of the choice the runtime would pick by default. Omitted when there is no eligible transport, or when the runtime expresses no preference.</summary>
    [JsonPropertyName("recommendedTransportChoiceId")]
    public string? RecommendedTransportChoiceId { get; set; }

    /// <summary>Whether applying this plan would require an MCP reload to take effect. Planning itself never reloads.</summary>
    [JsonPropertyName("reloadRequired")]
    public bool ReloadRequired { get; set; }

    /// <summary>Whether the plan cannot be applied without further input, because a required value has no default or a secret must be supplied.</summary>
    [JsonPropertyName("requiresInteractiveConfiguration")]
    public bool RequiresInteractiveConfiguration { get; set; }

    /// <summary>Configuration scope and key the plan would write to.</summary>
    [JsonPropertyName("target")]
    public McpPlanTarget Target { get => field ??= new(); set; }

    /// <summary>Every eligible transport, so a host can present an explicit choice. A completed plan always has at least one; when none is eligible, planning returns `CatalogUnavailableTransportError` instead.</summary>
    [JsonPropertyName("transportChoices")]
    public IList<McpPlanTransportChoice> TransportChoices { get => field ??= []; set; }
}

/// <summary>A computed MCP install plan. Nothing has been applied: the plan describes what installing would change, and the plan handle is what a later apply operation would consume.</summary>
/// <remarks>The <c>planned</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultPlanned : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "planned";

    /// <summary>Protocol version and capabilities the runtime honoured.</summary>
    [JsonPropertyName("negotiated")]
    public required CatalogNegotiatedContract Negotiated { get; set; }

    /// <summary>The normalised plan.</summary>
    [JsonPropertyName("plan")]
    public required McpInstallPlan Plan { get; set; }
}

/// <summary>The caller's protocol version or required capabilities cannot be honoured. Returned instead of a partial or ambiguous success.</summary>
/// <remarks>The <c>negotiation-refused</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultNegotiationRefused : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "negotiation-refused";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Lowest caller protocol version this runtime will serve.</summary>
    [JsonPropertyName("minimumSupportedProtocolVersion")]
    public required long MinimumSupportedProtocolVersion { get; set; }

    /// <summary>Whether the version or the capability set was the problem.</summary>
    [JsonPropertyName("reason")]
    public required CatalogNegotiationRefusedReason Reason { get; set; }

    /// <summary>Protocol version of the runtime that refused the request.</summary>
    [JsonPropertyName("runtimeProtocolVersion")]
    public required long RuntimeProtocolVersion { get; set; }

    /// <summary>Every wire feature this runtime understands, so the caller can retry within that contract. This list does not imply that every deployment has enabled every operation.</summary>
    [JsonPropertyName("supportedCapabilities")]
    public required IList<CatalogCapability> SupportedCapabilities { get; set; }

    /// <summary>The subset of the caller's bounded extensible capability identifiers this runtime cannot honour.</summary>
    [JsonPropertyName("unsupportedCapabilities")]
    public required IList<string> UnsupportedCapabilities { get; set; }
}

/// <summary>A presented handle was not accepted. Handles are runtime-instance scoped, TTL-bound, and single-use, so each way of failing is reported distinctly.</summary>
/// <remarks>The <c>handle-rejected</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultHandleRejected : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "handle-rejected";

    /// <summary>Which kind of handle was presented.</summary>
    [JsonPropertyName("handleType")]
    public required CatalogHandleType HandleType { get; set; }

    /// <summary>Human-readable explanation, safe to surface. Never contains the handle itself, nor a query, URL, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Why the handle was rejected.</summary>
    [JsonPropertyName("reason")]
    public required CatalogHandleRejectionReason Reason { get; set; }
}

/// <summary>The request was rejected before any work was done, because a bounded field fell outside its permitted range or a required field was unusable.</summary>
/// <remarks>The <c>invalid-request</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultInvalidRequest : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "invalid-request";

    /// <summary>Which request field was rejected.</summary>
    [JsonPropertyName("field")]
    public required CatalogInvalidRequestField Field { get; set; }

    /// <summary>Human-readable explanation, safe to surface. Never echoes the offending value, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }
}

/// <summary>An optional catalog authentication exchange did not establish the caller's identity. Anonymous search remains supported; this refusal is reserved for an operation that cannot continue after the attempted exchange. It is distinct from `policy-rejected` and from a network failure, and the reason identifies the recovery action.</summary>
/// <remarks>The <c>authentication-required</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultAuthenticationRequired : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "authentication-required";

    /// <summary>Human-readable explanation, safe to surface. Never contains a credential or token, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Why authentication failed. Only an expired credential justifies attempting a silent refresh; an absent or rejected credential requires sign-in.</summary>
    [JsonPropertyName("reason")]
    public required CatalogAuthenticationRequiredReason Reason { get; set; }
}

/// <summary>Registry or enterprise policy refused the operation.</summary>
/// <remarks>The <c>policy-rejected</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultPolicyRejected : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "policy-rejected";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Which authority produced the decision.</summary>
    [JsonPropertyName("source")]
    public required McpPlanPolicySource Source { get; set; }
}

/// <summary>The runtime could not reach the catalog authority or retrieve a card. Covers being offline as well as transport-level failure.</summary>
/// <remarks>The <c>network-failure</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultNetworkFailure : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "network-failure";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Categorised failure, low cardinality so it can be aggregated without carrying a URL.</summary>
    [JsonPropertyName("reason")]
    public required CatalogNetworkFailureReason Reason { get; set; }

    /// <summary>Bounded cooldown in seconds before another catalog request should be attempted, when the authority supplied a numeric Retry-After value or the runtime applied its documented fallback.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("retryAfterSeconds")]
    public int? RetryAfterSeconds { get; set; }

    /// <summary>HTTP status code, when the failure was a rejected response.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("statusCode")]
    public int? StatusCode { get; set; }
}

/// <summary>Retrieval was refused by the runtime's hardened fetch boundary before any request left the process, or before a redirect was followed.</summary>
/// <remarks>The <c>unsafe-retrieval</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultUnsafeRetrieval : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "unsafe-retrieval";

    /// <summary>Human-readable explanation, safe to surface. Never contains the refused URL, nor a query, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Which control refused the retrieval, low cardinality so it can be aggregated without carrying a URL.</summary>
    [JsonPropertyName("reason")]
    public required CatalogUnsafeRetrievalReason Reason { get; set; }
}

/// <summary>A card could not be parsed or did not satisfy its declared media type's schema.</summary>
/// <remarks>The <c>malformed-card</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultMalformedCard : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "malformed-card";

    /// <summary>Media type the card was interpreted as, when it declared one this runtime recognises.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mediaType")]
    public CatalogMediaType? MediaType { get; set; }

    /// <summary>Human-readable explanation, safe to surface. Never echoes card content, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>How the card failed validation.</summary>
    [JsonPropertyName("reason")]
    public required CatalogMalformedCardReason Reason { get; set; }
}

/// <summary>An upstream catalog response broke the wire contract. Most importantly, every result must carry exactly one of a URL or embedded data: a result carrying both, or neither, is refused here rather than being guessed at.</summary>
/// <remarks>The <c>contract-violation</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultContractViolation : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "contract-violation";

    /// <summary>Human-readable explanation, safe to surface. Never echoes response content, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Which rule the response broke.</summary>
    [JsonPropertyName("reason")]
    public required CatalogContractViolationReason Reason { get; set; }
}

/// <summary>No transport this runtime can use is available for the requested server.</summary>
/// <remarks>The <c>unavailable-transport</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultUnavailableTransport : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "unavailable-transport";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Why no transport could be offered.</summary>
    [JsonPropertyName("reason")]
    public required CatalogUnavailableTransportReason Reason { get; set; }
}

/// <summary>The candidate is discoverable but cannot be installed. `application/ai-skill` resolves here, because it stays searchable while remaining typed non-installable.</summary>
/// <remarks>The <c>not-installable</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultNotInstallable : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "not-installable";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Why the candidate cannot be installed.</summary>
    [JsonPropertyName("reason")]
    public required CatalogNotInstallableReason Reason { get; set; }
}

/// <summary>The operation is not available on this runtime. Distinct from a network failure: nothing was attempted.</summary>
/// <remarks>The <c>unavailable</c> variant of <see cref="McpPlanInstallResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallResultUnavailable : McpPlanInstallResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "unavailable";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Why the operation is unavailable.</summary>
    [JsonPropertyName("reason")]
    public required CatalogUnavailableReason Reason { get; set; }
}

/// <summary>The protocol version and capability set a caller requires, supplied on every catalog request so negotiation cannot be skipped by omission.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CatalogClientContract
{
    /// <summary>SDK protocol version the caller was generated against. A caller below the runtime's minimum supported version is refused rather than served a partial result.</summary>
    [JsonPropertyName("protocolVersion")]
    public long ProtocolVersion { get; set; }

    /// <summary>Wire features the caller requires the runtime to understand. Identifiers are bounded but extensible so a newer caller can negotiate with an older runtime. Requiring an unknown feature yields a typed refusal listing what is understood, never a partial grant. A grant does not promise that a deployment has enabled the operation; typed unavailable results report that separately.</summary>
    [JsonPropertyName("requiredCapabilities")]
    public IList<string> RequiredCapabilities { get => field ??= []; set; }
}

/// <summary>What an install plan is computed from: a candidate handle from a previous search, or a card supplied directly.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpPlanInstallSourceCandidate), "candidate")]
[JsonDerivedType(typeof(McpPlanInstallSourceCard), "card")]
public partial class McpPlanInstallSource
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Plan from a candidate returned by a previous catalog search.</summary>
/// <remarks>The <c>candidate</c> variant of <see cref="McpPlanInstallSource"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallSourceCandidate : McpPlanInstallSource
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "candidate";

    /// <summary>Single-use candidate handle. Consumed by this call, so a replay of the same handle is rejected.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(256)]
    [JsonPropertyName("candidateHandle")]
    public required string CandidateHandle { get; set; }

    /// <summary>The runtime- or authority-minted `searchId` returned with the search that produced this candidate. A search implementation binds it to private candidate-handle context; a planning implementation must verify that context before returning a plan. The unavailable planning implementation in this contract layer validates presence but does not claim the verification has occurred. It identifies a search rather than a person and must never be joined with user identity to re-identify anyone.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(64)]
    [JsonPropertyName("searchId")]
    public required string SearchId { get; set; }
}

/// <summary>A card supplied directly by the caller. Exactly one of a URL or embedded data, encoded structurally so neither both nor neither can be expressed.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpServerCardReferenceUrl), "url")]
[JsonDerivedType(typeof(McpServerCardReferenceEmbedded), "embedded")]
public partial class McpServerCardReference
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>An MCP server card to be retrieved from a URL through the runtime's hardened fetch boundary.</summary>
/// <remarks>The <c>url</c> variant of <see cref="McpServerCardReference"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpServerCardReferenceUrl : McpServerCardReference
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "url";

    /// <summary>Media type the card is expected to conform to.</summary>
    [JsonPropertyName("mediaType")]
    public required McpServerCardMediaType MediaType { get; set; }

    /// <summary>Card URL. Retrieved only through the runtime's hardened boundary, with scheme, credential, address-range, redirect, timeout, and response-size controls applied. Never logged.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(2048)]
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>An MCP server card supplied inline as an inert document.</summary>
/// <remarks>The <c>embedded</c> variant of <see cref="McpServerCardReference"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpServerCardReferenceEmbedded : McpServerCardReference
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "embedded";

    /// <summary>The card document verbatim, treated as inert untrusted bytes. The runtime parses and validates it; the host is not expected to interpret it. Never logged.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(1048576)]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>Media type the card is expected to conform to.</summary>
    [JsonPropertyName("mediaType")]
    public required McpServerCardMediaType MediaType { get; set; }
}

/// <summary>Plan from a card supplied directly by the caller, without a preceding search.</summary>
/// <remarks>The <c>card</c> variant of <see cref="McpPlanInstallSource"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class McpPlanInstallSourceCard : McpPlanInstallSource
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "card";

    /// <summary>The card to plan from: exactly one of a URL or embedded data.</summary>
    [JsonPropertyName("card")]
    public required McpServerCardReference Card { get; set; }
}

/// <summary>A side-effect-free request for an MCP install plan. Computing a plan never writes configuration, stores a secret, or reloads MCP servers.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpPlanInstallRequest
{
    /// <summary>Protocol version and capabilities the caller requires.</summary>
    [JsonPropertyName("contract")]
    public CatalogClientContract Contract { get => field ??= new(); set; }

    /// <summary>Configuration scope the plan targets. Defaults to user scope when omitted.</summary>
    [JsonPropertyName("scope")]
    public McpPlanScope? Scope { get; set; }

    /// <summary>What to plan: either a candidate handle from a previous search, or a card supplied directly.</summary>
    [JsonPropertyName("source")]
    public McpPlanInstallSource Source { get => field ??= new(); set; }
}

/// <summary>User-configured MCP servers, keyed by server name.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpConfigList
{
    /// <summary>All MCP servers from user config, keyed by name.</summary>
    [JsonPropertyName("servers")]
    public IDictionary<string, JsonElement> Servers { get => field ??= new Dictionary<string, JsonElement>(); set; }
}

/// <summary>MCP server name and configuration to add to user configuration.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpConfigAddRequest
{
    /// <summary>MCP server configuration (stdio process or remote HTTP/SSE).</summary>
    [JsonPropertyName("config")]
    public JsonElement Config { get; set; }

    /// <summary>Unique name for the MCP server.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>MCP server name and replacement configuration to write to user configuration.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpConfigUpdateRequest
{
    /// <summary>MCP server configuration (stdio process or remote HTTP/SSE).</summary>
    [JsonPropertyName("config")]
    public JsonElement Config { get; set; }

    /// <summary>Name of the MCP server to update.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>MCP server name to remove from user configuration.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpConfigRemoveRequest
{
    /// <summary>OAuth Client ID Metadata Document URL whose persisted credentials should also be removed.</summary>
    [JsonPropertyName("authClientIdMetadataUrl")]
    public string? AuthClientIdMetadataUrl { get; set; }

    /// <summary>Name of the MCP server to remove.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>MCP server names to enable for new sessions.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpConfigEnableRequest
{
    /// <summary>Names of MCP servers to enable. Each server is removed from the persisted disabled list so new sessions spawn it. Unknown or already-enabled names are ignored.</summary>
    [JsonPropertyName("names")]
    public IList<string> Names { get => field ??= []; set; }
}

/// <summary>MCP server names to disable for new sessions.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpConfigDisableRequest
{
    /// <summary>Names of MCP servers to disable. Each server is added to the persisted disabled list so new sessions skip it. Already-disabled names are ignored. Active sessions keep their current connections until they end.</summary>
    [JsonPropertyName("names")]
    public IList<string> Names { get => field ??= []; set; }
}

/// <summary>Installed plugin that contributes a discovered extension.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DiscoveredExtensionPlugin
{
    /// <summary>Installed plugin name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Discovered extension metadata and persistent enablement state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DiscoveredExtension
{
    /// <summary>Whether this extension's persistent per-ID preference is enabled.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Source-qualified ID accepted by both server and session extension enablement methods.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Human-readable extension name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Absolute path to the extension entry module, suitable for revealing it in a file manager.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Containing plugin metadata for plugin-contributed extensions.</summary>
    [JsonPropertyName("plugin")]
    public DiscoveredExtensionPlugin? Plugin { get; set; }

    /// <summary>Discovery source.</summary>
    [JsonPropertyName("source")]
    public DiscoveredExtensionSource Source { get; set; }
}

/// <summary>Extensions discovered from persisted Copilot home state and their effective loading mode. Launch-scoped additional plugins are not included.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DiscoveredExtensions
{
    /// <summary>Discovered user and enabled installed-plugin extensions from persisted Copilot home state.</summary>
    [JsonPropertyName("extensions")]
    public IList<DiscoveredExtension> Extensions { get => field ??= []; set; }

    /// <summary>Effective extension loading mode. Defaults to load_and_augment when unset.</summary>
    [JsonPropertyName("mode")]
    public DiscoveredExtensionMode Mode { get; set; }
}

/// <summary>Source-qualified extension identifiers to persistently enable for future sessions.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class DiscoveredExtensionsEnableRequest
{
    /// <summary>Source-qualified user or plugin extension IDs to enable.</summary>
    [JsonPropertyName("ids")]
    public IList<string> Ids { get => field ??= []; set; }
}

/// <summary>Source-qualified extension identifiers to persistently disable for future sessions.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class DiscoveredExtensionsDisableRequest
{
    /// <summary>Source-qualified user or plugin extension IDs to disable.</summary>
    [JsonPropertyName("ids")]
    public IList<string> Ids { get => field ??= []; set; }
}

/// <summary>Outcome of a catalog.search call: either bounded inert candidates, or one typed refusal. Never a partial success.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(CatalogSearchResultSucceeded), "succeeded")]
[JsonDerivedType(typeof(CatalogSearchResultNegotiationRefused), "negotiation-refused")]
[JsonDerivedType(typeof(CatalogSearchResultUnsupportedKind), "unsupported-kind")]
[JsonDerivedType(typeof(CatalogSearchResultInvalidRequest), "invalid-request")]
[JsonDerivedType(typeof(CatalogSearchResultAuthenticationRequired), "authentication-required")]
[JsonDerivedType(typeof(CatalogSearchResultPolicyRejected), "policy-rejected")]
[JsonDerivedType(typeof(CatalogSearchResultNetworkFailure), "network-failure")]
[JsonDerivedType(typeof(CatalogSearchResultUnsafeRetrieval), "unsafe-retrieval")]
[JsonDerivedType(typeof(CatalogSearchResultMalformedCard), "malformed-card")]
[JsonDerivedType(typeof(CatalogSearchResultContractViolation), "contract-violation")]
[JsonDerivedType(typeof(CatalogSearchResultUnavailable), "unavailable")]
public partial class CatalogSearchResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>One inert catalog result, represented as an MCP server or discovery-only AI skill variant so kind, media type, provenance, and installability cannot contradict each other.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(CatalogCandidateMcpServer), "mcp-server")]
[JsonDerivedType(typeof(CatalogCandidateAiSkill), "ai-skill")]
public partial class CatalogCandidate
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Where and when an MCP server catalog reference was observed. Discovery provenance deliberately carries no content digest because search does not establish the exact validated content a later plan will bind.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CatalogMcpServerCandidateProvenance
{
    /// <summary>Host of the catalog authority that advertised the reference, without path, query, or credentials. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("authority")]
    public string Authority { get; set; } = string.Empty;

    /// <summary>JSON MCP media type advertised for the referenced card.</summary>
    [JsonPropertyName("mediaType")]
    public McpServerCardMediaType MediaType { get; set; }

    /// <summary>ISO 8601 timestamp at which the runtime observed the catalog reference. This is not a retrieval or validation timestamp.</summary>
    [JsonPropertyName("observedAt")]
    public string ObservedAt { get; set; } = string.Empty;
}

/// <summary>Where a candidate's card came from. Exactly one of a URL or embedded data: the union has no variant carrying both, and no variant carrying neither, so the rule holds structurally rather than by validation.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(CatalogCandidateSourceUrl), "url")]
[JsonDerivedType(typeof(CatalogCandidateSourceEmbedded), "embedded")]
public partial class CatalogCandidateSource
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Candidate whose card is retrieved from a URL through the runtime's hardened fetch boundary.</summary>
/// <remarks>The <c>url</c> variant of <see cref="CatalogCandidateSource"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogCandidateSourceUrl : CatalogCandidateSource
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "url";

    /// <summary>Card URL as advertised. Inert untrusted data: the runtime retrieves it only through its own hardened boundary, and it is never logged.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Candidate whose card reference arrived inline. The document and its content-derived properties stay behind the runtime boundary.</summary>
/// <remarks>The <c>embedded</c> variant of <see cref="CatalogCandidateSource"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogCandidateSourceEmbedded : CatalogCandidateSource
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "embedded";
}

/// <summary>An inert MCP server catalog result. Every free-text field is untrusted external data and must never be treated as an instruction, and the handle is the only way to refer to the candidate in a later operation.</summary>
/// <remarks>The <c>mcp-server</c> variant of <see cref="CatalogCandidate"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogCandidateMcpServer : CatalogCandidate
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp-server";

    /// <summary>Description taken verbatim from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Display name taken verbatim from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(200)]
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Opaque, runtime-instance scoped, TTL-bound, single-use handle for this candidate. Carries no readable information and is rejected when stale, replayed, or presented to a different runtime instance. Never logged.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("handle")]
    public required string Handle { get; set; }

    /// <summary>ISO 8601 timestamp after which the handle is stale and will be rejected.</summary>
    [JsonPropertyName("handleExpiresAt")]
    public required string HandleExpiresAt { get; set; }

    /// <summary>Whether this MCP server can be planned for installation, and if policy prevents it.</summary>
    [JsonPropertyName("installability")]
    public required CatalogMcpServerInstallability Installability { get; set; }

    /// <summary>JSON MCP media type of the underlying card.</summary>
    [JsonPropertyName("mediaType")]
    public required McpServerCardMediaType MediaType { get; set; }

    /// <summary>Where the catalog reference was observed, without the card itself or any content digest.</summary>
    [JsonPropertyName("provenance")]
    public required CatalogMcpServerCandidateProvenance Provenance { get; set; }

    /// <summary>Publisher taken verbatim from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(200)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("publisher")]
    public string? Publisher { get; set; }

    /// <summary>Where the card came from: exactly one of a URL or embedded data, encoded as a tagged union so neither both nor neither can be represented.</summary>
    [JsonPropertyName("source")]
    public required CatalogCandidateSource Source { get; set; }
}

/// <summary>Where and when an AI skill catalog reference was observed. Discovery provenance deliberately carries no content digest because search does not establish the exact validated content a later plan will bind.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CatalogAiSkillCandidateProvenance
{
    /// <summary>Host of the catalog authority that advertised the reference, without path, query, or credentials. Inert untrusted data.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("authority")]
    public string Authority { get; set; } = string.Empty;

    /// <summary>Media type advertised for the referenced AI skill card.</summary>
    [JsonPropertyName("mediaType")]
    public string MediaType { get; set; } = string.Empty;

    /// <summary>ISO 8601 timestamp at which the runtime observed the catalog reference. This is not a retrieval or validation timestamp.</summary>
    [JsonPropertyName("observedAt")]
    public string ObservedAt { get; set; } = string.Empty;
}

/// <summary>An inert AI skill catalog result. AI skills are discovery-only and cannot be represented as installable through this surface.</summary>
/// <remarks>The <c>ai-skill</c> variant of <see cref="CatalogCandidate"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogCandidateAiSkill : CatalogCandidate
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "ai-skill";

    /// <summary>Description taken verbatim from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Display name taken verbatim from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(200)]
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Opaque, runtime-instance scoped, TTL-bound, single-use handle for this candidate. Carries no readable information and is rejected when stale, replayed, or presented to a different runtime instance. Never logged.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("handle")]
    public required string Handle { get; set; }

    /// <summary>ISO 8601 timestamp after which the handle is stale and will be rejected.</summary>
    [JsonPropertyName("handleExpiresAt")]
    public required string HandleExpiresAt { get; set; }

    /// <summary>AI skills are discovery-only and cannot be installed through this surface.</summary>
    [JsonPropertyName("installability")]
    public required string Installability { get; set; }

    /// <summary>Media type of the underlying AI skill card.</summary>
    [JsonPropertyName("mediaType")]
    public required string MediaType { get; set; }

    /// <summary>Where the catalog reference was observed, without the card itself or any content digest.</summary>
    [JsonPropertyName("provenance")]
    public required CatalogAiSkillCandidateProvenance Provenance { get; set; }

    /// <summary>Publisher taken verbatim from the card. Inert untrusted text.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(200)]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("publisher")]
    public string? Publisher { get; set; }

    /// <summary>Where the card came from: exactly one of a URL or embedded data, encoded as a tagged union so neither both nor neither can be represented.</summary>
    [JsonPropertyName("source")]
    public required CatalogCandidateSource Source { get; set; }
}

/// <summary>A completed catalog search: inert candidate summaries, each carrying a single-use handle.</summary>
/// <remarks>The <c>succeeded</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultSucceeded : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "succeeded";

    /// <summary>Matching candidates, never more than the requested limit. All text is inert untrusted data.</summary>
    [JsonPropertyName("candidates")]
    public required IList<CatalogCandidate> Candidates { get; set; }

    /// <summary>Protocol version and capabilities the runtime honoured.</summary>
    [JsonPropertyName("negotiated")]
    public required CatalogNegotiatedContract Negotiated { get; set; }

    /// <summary>Pseudonymous identifier for this search, issued by the runtime or by the catalog authority it queried and never by the caller, so it cannot be forged or replayed to attribute an install to a search that never happened. Always present on a success, so a result set can be tied to the installs it leads to. It identifies a search rather than a person: it is derived from no user, account, device, or query data, and must never be joined with user identity to re-identify anyone.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(64)]
    [JsonPropertyName("searchId")]
    public required string SearchId { get; set; }

    /// <summary>Whether further matches existed beyond the requested limit.</summary>
    [JsonPropertyName("truncated")]
    public required bool Truncated { get; set; }
}

/// <summary>The caller's protocol version or required capabilities cannot be honoured. Returned instead of a partial or ambiguous success.</summary>
/// <remarks>The <c>negotiation-refused</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultNegotiationRefused : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "negotiation-refused";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Lowest caller protocol version this runtime will serve.</summary>
    [JsonPropertyName("minimumSupportedProtocolVersion")]
    public required long MinimumSupportedProtocolVersion { get; set; }

    /// <summary>Whether the version or the capability set was the problem.</summary>
    [JsonPropertyName("reason")]
    public required CatalogNegotiationRefusedReason Reason { get; set; }

    /// <summary>Protocol version of the runtime that refused the request.</summary>
    [JsonPropertyName("runtimeProtocolVersion")]
    public required long RuntimeProtocolVersion { get; set; }

    /// <summary>Every wire feature this runtime understands, so the caller can retry within that contract. This list does not imply that every deployment has enabled every operation.</summary>
    [JsonPropertyName("supportedCapabilities")]
    public required IList<CatalogCapability> SupportedCapabilities { get; set; }

    /// <summary>The subset of the caller's bounded extensible capability identifiers this runtime cannot honour.</summary>
    [JsonPropertyName("unsupportedCapabilities")]
    public required IList<string> UnsupportedCapabilities { get; set; }
}

/// <summary>The request asked for a candidate kind this runtime does not serve.</summary>
/// <remarks>The <c>unsupported-kind</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultUnsupportedKind : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "unsupported-kind";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>The kinds from the request that are not supported.</summary>
    [JsonPropertyName("requestedKinds")]
    public required IList<CatalogCandidateKind> RequestedKinds { get; set; }

    /// <summary>Every candidate kind this runtime can serve.</summary>
    [JsonPropertyName("supportedKinds")]
    public required IList<CatalogCandidateKind> SupportedKinds { get; set; }
}

/// <summary>The request was rejected before any work was done, because a bounded field fell outside its permitted range or a required field was unusable.</summary>
/// <remarks>The <c>invalid-request</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultInvalidRequest : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "invalid-request";

    /// <summary>Which request field was rejected.</summary>
    [JsonPropertyName("field")]
    public required CatalogInvalidRequestField Field { get; set; }

    /// <summary>Human-readable explanation, safe to surface. Never echoes the offending value, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }
}

/// <summary>An optional catalog authentication exchange did not establish the caller's identity. Anonymous search remains supported; this refusal is reserved for an operation that cannot continue after the attempted exchange. It is distinct from `policy-rejected` and from a network failure, and the reason identifies the recovery action.</summary>
/// <remarks>The <c>authentication-required</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultAuthenticationRequired : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "authentication-required";

    /// <summary>Human-readable explanation, safe to surface. Never contains a credential or token, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Why authentication failed. Only an expired credential justifies attempting a silent refresh; an absent or rejected credential requires sign-in.</summary>
    [JsonPropertyName("reason")]
    public required CatalogAuthenticationRequiredReason Reason { get; set; }
}

/// <summary>Registry or enterprise policy refused the operation.</summary>
/// <remarks>The <c>policy-rejected</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultPolicyRejected : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "policy-rejected";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Which authority produced the decision.</summary>
    [JsonPropertyName("source")]
    public required McpPlanPolicySource Source { get; set; }
}

/// <summary>The runtime could not reach the catalog authority or retrieve a card. Covers being offline as well as transport-level failure.</summary>
/// <remarks>The <c>network-failure</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultNetworkFailure : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "network-failure";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Categorised failure, low cardinality so it can be aggregated without carrying a URL.</summary>
    [JsonPropertyName("reason")]
    public required CatalogNetworkFailureReason Reason { get; set; }

    /// <summary>Bounded cooldown in seconds before another catalog request should be attempted, when the authority supplied a numeric Retry-After value or the runtime applied its documented fallback.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("retryAfterSeconds")]
    public int? RetryAfterSeconds { get; set; }

    /// <summary>HTTP status code, when the failure was a rejected response.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("statusCode")]
    public int? StatusCode { get; set; }
}

/// <summary>Retrieval was refused by the runtime's hardened fetch boundary before any request left the process, or before a redirect was followed.</summary>
/// <remarks>The <c>unsafe-retrieval</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultUnsafeRetrieval : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "unsafe-retrieval";

    /// <summary>Human-readable explanation, safe to surface. Never contains the refused URL, nor a query, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Which control refused the retrieval, low cardinality so it can be aggregated without carrying a URL.</summary>
    [JsonPropertyName("reason")]
    public required CatalogUnsafeRetrievalReason Reason { get; set; }
}

/// <summary>A card could not be parsed or did not satisfy its declared media type's schema.</summary>
/// <remarks>The <c>malformed-card</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultMalformedCard : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "malformed-card";

    /// <summary>Media type the card was interpreted as, when it declared one this runtime recognises.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mediaType")]
    public CatalogMediaType? MediaType { get; set; }

    /// <summary>Human-readable explanation, safe to surface. Never echoes card content, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>How the card failed validation.</summary>
    [JsonPropertyName("reason")]
    public required CatalogMalformedCardReason Reason { get; set; }
}

/// <summary>An upstream catalog response broke the wire contract. Most importantly, every result must carry exactly one of a URL or embedded data: a result carrying both, or neither, is refused here rather than being guessed at.</summary>
/// <remarks>The <c>contract-violation</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultContractViolation : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "contract-violation";

    /// <summary>Human-readable explanation, safe to surface. Never echoes response content, nor a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Which rule the response broke.</summary>
    [JsonPropertyName("reason")]
    public required CatalogContractViolationReason Reason { get; set; }
}

/// <summary>The operation is not available on this runtime. Distinct from a network failure: nothing was attempted.</summary>
/// <remarks>The <c>unavailable</c> variant of <see cref="CatalogSearchResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class CatalogSearchResultUnavailable : CatalogSearchResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "unavailable";

    /// <summary>Human-readable explanation, safe to surface. Never contains a query, URL, handle, or secret.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(1000)]
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Why the operation is unavailable.</summary>
    [JsonPropertyName("reason")]
    public required CatalogUnavailableReason Reason { get; set; }
}

/// <summary>A bounded catalog search. Both the query length and the result count are capped by the schema so a caller cannot request an unbounded scan.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CatalogSearchRequest
{
    /// <summary>Protocol version and capabilities the caller requires.</summary>
    [JsonPropertyName("contract")]
    public CatalogClientContract Contract { get => field ??= new(); set; }

    /// <summary>Restrict results to these candidate kinds. When omitted, every kind the runtime supports is searched.</summary>
    [JsonPropertyName("kinds")]
    public IList<CatalogCandidateKind>? Kinds { get; set; }

    /// <summary>Maximum number of candidates to return. Defaults to 10 when omitted.</summary>
    [JsonPropertyName("limit")]
    public int? Limit { get; set; }

    /// <summary>Free-text search query. Persisted as tool input for session continuity, but omitted from telemetry.</summary>
    [RegularExpression("\\S")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(256)]
    [JsonPropertyName("query")]
    public string Query { get; set; } = string.Empty;
}

/// <summary>Information about an installed plugin tracked in global state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InstalledPluginInfo
{
    /// <summary>Opaque, stable hash identifying a direct (non-marketplace) install source. Present only for direct repo / URL / local installs; absent for marketplace plugins. Same source yields the same id; distinct sources never collide.</summary>
    [JsonPropertyName("directSourceId")]
    public string? DirectSourceId { get; set; }

    /// <summary>Whether the plugin is currently enabled for new sessions.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Absolute path of the marketplace directory a live plugin was resolved from. Present only on live, never-persisted records — a plugin belonging to a directory/local marketplace, which is loaded from its real directory on every pass instead of a copy under the installed-plugins cache. Its presence is what marks a listed plugin as live: such a plugin is always present on disk, so `enabled` is its only meaningful state and it is never "not installed".</summary>
    [JsonPropertyName("installedFrom")]
    public string? InstalledFrom { get; set; }

    /// <summary>Marketplace the plugin came from. Empty string ("") for direct repo / URL / local installs.</summary>
    [JsonPropertyName("marketplace")]
    public string Marketplace { get; set; } = string.Empty;

    /// <summary>Plugin name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Installed version (when reported by the plugin manifest).</summary>
    [JsonPropertyName("version")]
    public string? Version { get; set; }
}

/// <summary>Plugins installed in user/global state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PluginListResult
{
    /// <summary>Installed plugins.</summary>
    [JsonPropertyName("plugins")]
    public IList<InstalledPluginInfo> Plugins { get => field ??= []; set; }
}

/// <summary>Result of installing a plugin.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PluginInstallResult
{
    /// <summary>Set when the install path is deprecated (e.g. direct repo / URL / local installs). Callers should surface this to end users.</summary>
    [JsonPropertyName("deprecationWarning")]
    public string? DeprecationWarning { get; set; }

    /// <summary>The newly installed plugin's metadata.</summary>
    [JsonPropertyName("plugin")]
    public InstalledPluginInfo Plugin { get => field ??= new(); set; }

    /// <summary>Optional post-install message provided by the plugin (e.g. setup instructions).</summary>
    [JsonPropertyName("postInstallMessage")]
    public string? PostInstallMessage { get; set; }

    /// <summary>Number of skills discovered and installed from the plugin.</summary>
    [JsonPropertyName("skillsInstalled")]
    public long SkillsInstalled { get; set; }

    /// <summary>Where the completed plugin tree was staged before atomic promotion.</summary>
    [JsonPropertyName("stagingMode")]
    public PluginInstallStagingMode? StagingMode { get; set; }
}

/// <summary>Plugin source and optional working directory for relative-path resolution.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsInstallRequest
{
    /// <summary>Plugin install spec. Accepts the same forms as the CLI: "plugin@marketplace" (marketplace install), "owner/repo" or "owner/repo:subpath" (GitHub direct), an http/https/ssh URL, or a local path. Direct (non-marketplace) installs are deprecated and will produce a deprecationWarning in the result.</summary>
    [JsonPropertyName("source")]
    public string Source { get; set; } = string.Empty;

    /// <summary>Working directory used to resolve relative local paths in `source`. Defaults to the server's current working directory.</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Name (or spec) of the plugin to uninstall.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsUninstallRequest
{
    /// <summary>Stable source identity for a direct (non-marketplace) install. Disambiguates uninstall when multiple installed plugins share the same name.</summary>
    [JsonPropertyName("directSourceId")]
    public string? DirectSourceId { get; set; }

    /// <summary>Plugin name or "plugin@marketplace" spec to uninstall. When ambiguous, prefer the fully-qualified spec.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Result of updating a single plugin.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PluginUpdateResult
{
    /// <summary>Version after the update, when reported by the plugin manifest.</summary>
    [JsonPropertyName("newVersion")]
    public string? NewVersion { get; set; }

    /// <summary>Version that was previously installed, when available.</summary>
    [JsonPropertyName("previousVersion")]
    public string? PreviousVersion { get; set; }

    /// <summary>Number of skills discovered and installed after the update.</summary>
    [JsonPropertyName("skillsInstalled")]
    public long SkillsInstalled { get; set; }
}

/// <summary>Name (or spec) of the plugin to update.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsUpdateRequest
{
    /// <summary>Plugin name or "plugin@marketplace" spec to update.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Per-plugin result from updating all plugins, with versions, skills installed, success flag, and optional error.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PluginUpdateAllEntry
{
    /// <summary>Error message (failure only).</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Marketplace the plugin came from. Empty string ("") for direct installs.</summary>
    [JsonPropertyName("marketplace")]
    public string Marketplace { get; set; } = string.Empty;

    /// <summary>Plugin name that was updated.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Version after the update, when available.</summary>
    [JsonPropertyName("newVersion")]
    public string? NewVersion { get; set; }

    /// <summary>Previously installed version, when available.</summary>
    [JsonPropertyName("previousVersion")]
    public string? PreviousVersion { get; set; }

    /// <summary>Number of skills installed after the update (success only).</summary>
    [JsonPropertyName("skillsInstalled")]
    public long? SkillsInstalled { get; set; }

    /// <summary>Whether the update succeeded for this plugin.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Result of updating all installed plugins.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PluginUpdateAllResult
{
    /// <summary>Per-plugin update results in deterministic order.</summary>
    [JsonPropertyName("results")]
    public IList<PluginUpdateAllEntry> Results { get => field ??= []; set; }
}

/// <summary>Plugin names (or specs) to enable, plus the optional working directory the repository-controlled guard is evaluated against.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsEnableRequest
{
    /// <summary>Plugin names or "plugin@marketplace" specs to enable. Unknown names are ignored. Non-marketplace direct installs are always enabled and cannot be toggled via this API.</summary>
    [JsonPropertyName("names")]
    public IList<string> Names { get => field ??= []; set; }

    /// <summary>Working directory whose repository `enabledPlugins` overlay decides whether this mutation is repository-controlled. Hosts that serve sessions across several repositories (the SDK server) should pass the session's directory; otherwise the guard is evaluated against the server process's own working directory, which may belong to a different repository. Defaults to the server's current working directory.</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Plugin names (or specs) to disable, plus the optional working directory the repository-controlled guard is evaluated against.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsDisableRequest
{
    /// <summary>Plugin names or "plugin@marketplace" specs to disable. Unknown names are ignored. Non-marketplace direct installs cannot be disabled via this API; uninstall them instead. Plugin-owned MCP servers are stopped in active sessions immediately; other plugin contributions remain available until each session reloads plugins.</summary>
    [JsonPropertyName("names")]
    public IList<string> Names { get => field ??= []; set; }

    /// <summary>Working directory whose repository `enabledPlugins` overlay decides whether this mutation is repository-controlled. Hosts that serve sessions across several repositories (the SDK server) should pass the session's directory; otherwise the guard is evaluated against the server process's own working directory, which may belong to a different repository. Defaults to the server's current working directory.</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Trusted built-in plugin directories to use for this runtime process.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsBuiltinSetRequest
{
    /// <summary>Complete replacement set of trusted built-in plugin directories. Every entry must be an absolute local filesystem path no longer than 4096 characters.</summary>
    [JsonPropertyName("paths")]
    public IList<string> Paths { get => field ??= []; set; }
}

/// <summary>Registered marketplace summary.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplaceInfo
{
    /// <summary>True when this is a default marketplace shipped with the runtime. Defaults are not removable.</summary>
    [JsonPropertyName("isDefault")]
    public bool? IsDefault { get; set; }

    /// <summary>Marketplace name (matches the @marketplace suffix in plugin specs).</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Human-readable description of where the marketplace data is fetched from (e.g. "GitHub: owner/repo").</summary>
    [JsonPropertyName("source")]
    public string Source { get; set; } = string.Empty;
}

/// <summary>All registered marketplaces, including built-in defaults.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplaceListResult
{
    /// <summary>Registered marketplaces.</summary>
    [JsonPropertyName("marketplaces")]
    public IList<MarketplaceInfo> Marketplaces { get => field ??= []; set; }
}

/// <summary>Result of registering a new marketplace.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplaceAddResult
{
    /// <summary>Final name of the marketplace as resolved from its manifest.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Marketplace source and optional working directory for relative-path resolution.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsMarketplacesAddRequest
{
    /// <summary>Marketplace source. Accepts the same forms as the CLI: "owner/repo" or "owner/repo#ref" (GitHub), an http/https/ssh URL (optionally with #ref), a git scp-style URL (user@host:path), or a local path. The marketplace's own name (from its manifest) is used as the registration key.</summary>
    [JsonPropertyName("source")]
    public string Source { get; set; } = string.Empty;

    /// <summary>Working directory used to resolve relative local paths in `source`. Defaults to the server's current working directory.</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Outcome of the remove attempt, including dependent-plugin info when applicable.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplaceRemoveResult
{
    /// <summary>Names of installed plugins that prevented removal. Populated only when `removed=false`.</summary>
    [JsonPropertyName("dependentPlugins")]
    public IList<string>? DependentPlugins { get; set; }

    /// <summary>True when the marketplace was actually removed. False when removal was skipped because the marketplace has dependent plugins and `force` was not set.</summary>
    [JsonPropertyName("removed")]
    public bool Removed { get; set; }
}

/// <summary>Name of the marketplace to remove and an optional force flag.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsMarketplacesRemoveRequest
{
    /// <summary>When true, also uninstall every plugin sourced from this marketplace. When false (default), removal is a no-op if any plugin from this marketplace is installed and the dependent plugin names are returned in the result.</summary>
    [JsonPropertyName("force")]
    public bool? Force { get; set; }

    /// <summary>Marketplace name to remove.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Plugin entry advertised by a marketplace.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplacePluginInfo
{
    /// <summary>Short description from the marketplace catalog, when present.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Plugin name as listed in the marketplace catalog.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Plugins advertised by the marketplace.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplaceBrowseResult
{
    /// <summary>Plugins advertised by the marketplace.</summary>
    [JsonPropertyName("plugins")]
    public IList<MarketplacePluginInfo> Plugins { get => field ??= []; set; }
}

/// <summary>Name of the marketplace whose plugin catalog to fetch.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsMarketplacesBrowseRequest
{
    /// <summary>Marketplace name to browse.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Per-marketplace refresh result, including marketplace name, success flag, and optional failure error.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplaceRefreshEntry
{
    /// <summary>Error message (failure only).</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Marketplace name that was refreshed.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Whether the refresh succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Result of refreshing one or more marketplace catalogs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MarketplaceRefreshResult
{
    /// <summary>Per-marketplace refresh results in deterministic order.</summary>
    [JsonPropertyName("results")]
    public IList<MarketplaceRefreshEntry> Results { get => field ??= []; set; }
}

/// <summary>RPC data type for PluginsMarketplacesRefresh operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PluginsMarketplacesRefreshRequest
{
    /// <summary>Marketplace name to refresh. When omitted, every registered marketplace is refreshed.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }
}

/// <summary>Server-side skill metadata, including name, description, source, enabled/invocable state, path, project path, and argument hint.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerSkill
{
    /// <summary>Optional freeform hint describing the skill's expected arguments, from the `argument-hint` frontmatter field.</summary>
    [JsonPropertyName("argumentHint")]
    public string? ArgumentHint { get; set; }

    /// <summary>Canonical slash command name used to invoke the skill, without the leading '/'.</summary>
    [JsonPropertyName("commandName")]
    public string? CommandName { get; set; }

    /// <summary>Description of what the skill does.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Whether the skill is currently enabled (based on global config).</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Unique identifier for the skill.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Absolute path to the skill file.</summary>
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>The project path this skill belongs to (only for project/inherited skills).</summary>
    [JsonPropertyName("projectPath")]
    public string? ProjectPath { get; set; }

    /// <summary>Source location type (e.g., project, personal-copilot, plugin, builtin).</summary>
    [JsonPropertyName("source")]
    public SkillSource Source { get; set; }

    /// <summary>Whether the skill can be invoked by the user as a slash command.</summary>
    [JsonPropertyName("userInvocable")]
    public bool UserInvocable { get; set; }
}

/// <summary>Skills discovered across global and project sources.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerSkillList
{
    /// <summary>Messages for skills that failed to load (e.g. malformed SKILL.md). Empty when host skills are excluded so host-local paths are not disclosed to multitenant callers.</summary>
    [JsonPropertyName("errors")]
    public IList<string>? Errors { get; set; }

    /// <summary>All discovered skills across all sources.</summary>
    [JsonPropertyName("skills")]
    public IList<ServerSkill> Skills { get => field ??= []; set; }
}

/// <summary>Optional project paths and additional skill directories to include in discovery.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SkillsDiscoverRequest
{
    /// <summary>When true, omit skills from the host's global sources (personal, custom, plugin, and built-in), returning only project-scoped skills. For multitenant deployments.</summary>
    [JsonPropertyName("excludeHostSkills")]
    public bool? ExcludeHostSkills { get; set; }

    /// <summary>Optional list of project directory paths to scan for project-scoped skills.</summary>
    [JsonPropertyName("projectPaths")]
    public IList<string>? ProjectPaths { get; set; }

    /// <summary>Optional list of additional skill directory paths to include.</summary>
    [JsonPropertyName("skillDirectories")]
    public IList<string>? SkillDirectories { get; set; }
}

/// <summary>Canonical directory where skills can be discovered or created, with scope, preference, and optional project path.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SkillDiscoveryPath
{
    /// <summary>Absolute path of the create/discovery target (may not exist on disk yet).</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Whether this is the canonical directory to create a new skill in its tier. At most one entry per tier is preferred; the `personal-agents` and `custom` scopes are never preferred.</summary>
    [JsonPropertyName("preferredForCreation")]
    public bool PreferredForCreation { get; set; }

    /// <summary>The input project path this directory was derived from (only for project scope).</summary>
    [JsonPropertyName("projectPath")]
    public string? ProjectPath { get; set; }

    /// <summary>Which tier this directory belongs to.</summary>
    [JsonPropertyName("scope")]
    public SkillDiscoveryScope Scope { get; set; }
}

/// <summary>Canonical locations where skills can be created so the runtime will recognize them.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SkillDiscoveryPathList
{
    /// <summary>Canonical skill create/discovery directories, in priority order.</summary>
    [JsonPropertyName("paths")]
    public IList<SkillDiscoveryPath> Paths { get => field ??= []; set; }
}

/// <summary>Optional project paths to enumerate.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SkillsGetDiscoveryPathsRequest
{
    /// <summary>When true, omit the host's personal and custom skill directories, leaving only project directories. For multitenant deployments.</summary>
    [JsonPropertyName("excludeHostSkills")]
    public bool? ExcludeHostSkills { get; set; }

    /// <summary>Optional list of project directory paths. When omitted or empty, only personal and custom directories are returned.</summary>
    [JsonPropertyName("projectPaths")]
    public IList<string>? ProjectPaths { get; set; }
}

/// <summary>Skill names to mark as disabled in global configuration, replacing any previous list.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SkillsConfigSetDisabledSkillsRequest
{
    /// <summary>List of skill names to disable.</summary>
    [JsonPropertyName("disabledSkills")]
    public IList<string> DisabledSkills { get => field ??= []; set; }
}

/// <summary>Adds or removes a single skill from the global disabled list, leaving every other entry untouched.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SkillsConfigSetSkillDisabledRequest
{
    /// <summary>True to disable the skill, false to enable it.</summary>
    [JsonPropertyName("disabled")]
    public bool Disabled { get; set; }

    /// <summary>Name of the skill to add to or remove from the disabled list.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Agent metadata, including identifiers, display details, source, tools, model, models, MCP servers, skills, and file path.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentInfo
{
    /// <summary>Description of the agent's purpose.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Whether model-driven invocation is disabled for this agent.</summary>
    [JsonPropertyName("disableModelInvocation")]
    public bool? DisableModelInvocation { get; set; }

    /// <summary>Human-readable display name.</summary>
    [JsonPropertyName("displayName")]
    public string DisplayName { get; set; } = string.Empty;

    /// <summary>Stable identifier for selection. For most agents this is the same as `name`; for plugin/builtin agents it may differ. Always populated; defaults to `name` when no distinct id was assigned.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>MCP server configurations attached to this agent, keyed by server name. Server config shape mirrors the MCP `mcpServers` schema.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonPropertyName("mcpServers")]
    public IDictionary<string, JsonElement>? McpServers { get; set; }

    /// <summary>Authored preferred model id for this agent. Runtime model selection may choose a different model; omitted means no authored preference.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Whether authored models are preferences or required constraints.</summary>
    [JsonPropertyName("modelPolicy")]
    public AgentModelPolicy? ModelPolicy { get; set; }

    /// <summary>Authored preferred model ids for this agent, in priority order. Runtime model selection chooses the first available model; omitted means no authored preference.</summary>
    [JsonPropertyName("models")]
    public IList<string>? Models { get; set; }

    /// <summary>Name of the agent. Use `id` as the stable selection identifier.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Absolute local file path of the agent definition. Only set for file-based agents loaded from disk; remote agents do not have a path.</summary>
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>Authored base prompt for the agent. Runtime prompt assembly may add dynamic context at invocation time. Omitted from `session.agent.list` unless `includePrompt` is true.</summary>
    [JsonPropertyName("prompt")]
    public string? Prompt { get; set; }

    /// <summary>Skill names preloaded into this agent's context. Omitted means none.</summary>
    [JsonPropertyName("skills")]
    public IList<string>? Skills { get; set; }

    /// <summary>Where the agent definition was loaded from.</summary>
    [JsonPropertyName("source")]
    public AgentInfoSource? Source { get; set; }

    /// <summary>Allowed tool names for this agent. Empty array means none; omitted means inherit defaults.</summary>
    [JsonPropertyName("tools")]
    public IList<string>? Tools { get; set; }

    /// <summary>Whether the agent can be selected directly by the user. Agents marked `false` are subagent-only.</summary>
    [JsonPropertyName("userInvocable")]
    public bool? UserInvocable { get; set; }
}

/// <summary>Agents discovered across user, project, plugin, and remote sources.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerAgentList
{
    /// <summary>All discovered agents across all sources.</summary>
    [JsonPropertyName("agents")]
    public IList<AgentInfo> Agents { get => field ??= []; set; }
}

/// <summary>Optional project paths to include in agent discovery.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AgentsDiscoverRequest
{
    /// <summary>When true, omit the host's agents (the user-level agent directory and all plugin agents), leaving only project and remote agents. For multitenant deployments.</summary>
    [JsonPropertyName("excludeHostAgents")]
    public bool? ExcludeHostAgents { get; set; }

    /// <summary>Optional list of project directory paths to scan for project-scoped agents. When omitted or empty, only user/plugin/remote-independent agents are returned (no project scan).</summary>
    [JsonPropertyName("projectPaths")]
    public IList<string>? ProjectPaths { get; set; }
}

/// <summary>Canonical directory where custom agents can be discovered or created, with scope, preference, and optional project path.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentDiscoveryPath
{
    /// <summary>Absolute path of the search/create directory (may not exist on disk yet).</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Whether this is the canonical directory to create a new agent in its tier. At most one entry per tier is preferred.</summary>
    [JsonPropertyName("preferredForCreation")]
    public bool PreferredForCreation { get; set; }

    /// <summary>The input project path this directory was derived from (only for project scope).</summary>
    [JsonPropertyName("projectPath")]
    public string? ProjectPath { get; set; }

    /// <summary>Which tier this directory belongs to.</summary>
    [JsonPropertyName("scope")]
    public AgentDiscoveryPathScope Scope { get; set; }
}

/// <summary>Canonical locations where custom agents can be created so the runtime will recognize them.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentDiscoveryPathList
{
    /// <summary>Canonical agent create/discovery directories, in priority order.</summary>
    [JsonPropertyName("paths")]
    public IList<AgentDiscoveryPath> Paths { get => field ??= []; set; }
}

/// <summary>Optional project paths to include when enumerating agent discovery directories.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AgentsGetDiscoveryPathsRequest
{
    /// <summary>When true, omit the host's user-level agent directory, leaving only project directories. For multitenant deployments (mirrors `discover`'s `excludeHostAgents`).</summary>
    [JsonPropertyName("excludeHostAgents")]
    public bool? ExcludeHostAgents { get; set; }

    /// <summary>Optional list of project directory paths. When omitted or empty, only the user-level directory is returned.</summary>
    [JsonPropertyName("projectPaths")]
    public IList<string>? ProjectPaths { get; set; }
}

/// <summary>Loaded instruction source for a session, including path, content, category, location, applicability, and optional description.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InstructionSource
{
    /// <summary>Glob pattern(s) from frontmatter — when set, this instruction applies only to matching files.</summary>
    [JsonPropertyName("applyTo")]
    public IList<string>? ApplyTo { get; set; }

    /// <summary>Raw content of the instruction file.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>When true, this source starts disabled and must be toggled on by the user.</summary>
    [JsonPropertyName("defaultDisabled")]
    public bool? DefaultDisabled { get; set; }

    /// <summary>Short description (body after frontmatter) for use in instruction tables.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Unique identifier for this source (used for toggling).</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Human-readable label.</summary>
    [JsonPropertyName("label")]
    public string Label { get; set; } = string.Empty;

    /// <summary>Where this source lives — used for UI grouping.</summary>
    [JsonPropertyName("location")]
    public InstructionSourceLocation Location { get; set; }

    /// <summary>The project path this source was discovered from. Only set by sessionless discovery for repository, working-directory, and project-scoped plugin sources, where it disambiguates sources across multiple workspace roots. The session-scoped getSources leaves it unset.</summary>
    [JsonPropertyName("projectPath")]
    public string? ProjectPath { get; set; }

    /// <summary>File path relative to repo or absolute for home.</summary>
    [JsonPropertyName("sourcePath")]
    public string SourcePath { get; set; } = string.Empty;

    /// <summary>Category of instruction source — used for merge logic.</summary>
    [JsonPropertyName("type")]
    public InstructionSourceType Type { get; set; }
}

/// <summary>Instruction sources discovered across user, repository, and plugin sources.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerInstructionSourceList
{
    /// <summary>All discovered instruction sources.</summary>
    [JsonPropertyName("sources")]
    public IList<InstructionSource> Sources { get => field ??= []; set; }
}

/// <summary>Optional project paths to include in instruction discovery.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class InstructionsDiscoverRequest
{
    /// <summary>When true, omit the host's instruction sources (user/home-level files and plugin rules), leaving only repository and working-directory sources. For multitenant deployments.</summary>
    [JsonPropertyName("excludeHostInstructions")]
    public bool? ExcludeHostInstructions { get; set; }

    /// <summary>Optional list of project directory paths to scan for repository/working-directory instruction sources. When omitted or empty, only user-level and plugin instruction sources are returned (no project scan).</summary>
    [JsonPropertyName("projectPaths")]
    public IList<string>? ProjectPaths { get; set; }
}

/// <summary>Canonical file or directory where custom instructions can be discovered or created, with location, kind, preference, and project path.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InstructionDiscoveryPath
{
    /// <summary>Whether the target is a single file or a directory of instruction files.</summary>
    [JsonPropertyName("kind")]
    public InstructionDiscoveryPathKind Kind { get; set; }

    /// <summary>Which tier this target belongs to.</summary>
    [JsonPropertyName("location")]
    public InstructionDiscoveryPathLocation Location { get; set; }

    /// <summary>Absolute path of the file or directory (may not exist on disk yet).</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Whether this is the canonical target to create new instructions in its tier. At most one entry per tier is preferred.</summary>
    [JsonPropertyName("preferredForCreation")]
    public bool PreferredForCreation { get; set; }

    /// <summary>The input project path this target was derived from (only for repository targets).</summary>
    [JsonPropertyName("projectPath")]
    public string? ProjectPath { get; set; }
}

/// <summary>Canonical files and directories where custom instructions can be created so the runtime will recognize them.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InstructionDiscoveryPathList
{
    /// <summary>Canonical instruction create/discovery files and directories, in priority order.</summary>
    [JsonPropertyName("paths")]
    public IList<InstructionDiscoveryPath> Paths { get => field ??= []; set; }
}

/// <summary>Optional project paths to include when enumerating instruction discovery targets.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class InstructionsGetDiscoveryPathsRequest
{
    /// <summary>When true, omit the host's user-level instruction targets, leaving only repository targets. For multitenant deployments (mirrors `discover`'s `excludeHostInstructions`).</summary>
    [JsonPropertyName("excludeHostInstructions")]
    public bool? ExcludeHostInstructions { get; set; }

    /// <summary>Optional list of project directory paths. When omitted or empty, only the user-level targets are returned.</summary>
    [JsonPropertyName("projectPaths")]
    public IList<string>? ProjectPaths { get; set; }
}

/// <summary>A literal choice the command input accepts, with a human-facing description.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SlashCommandInputChoice
{
    /// <summary>Human-readable description shown alongside the choice.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>The literal choice value (e.g. 'on', 'off', 'show').</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Optional unstructured input hint.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SlashCommandInput
{
    /// <summary>Optional literal choices the input accepts, each with a human-facing description; clients may render these as selectable options.</summary>
    [JsonPropertyName("choices")]
    public IList<SlashCommandInputChoice>? Choices { get; set; }

    /// <summary>Optional completion hint for the input (e.g. 'directory' for filesystem path completion).</summary>
    [JsonPropertyName("completion")]
    public SlashCommandInputCompletion? Completion { get; set; }

    /// <summary>Hint to display when command input has not been provided.</summary>
    [JsonPropertyName("hint")]
    public string Hint { get; set; } = string.Empty;

    /// <summary>When true, clients should pass the full text after the command name as a single argument rather than splitting on whitespace.</summary>
    [JsonPropertyName("preserveMultilineInput")]
    public bool? PreserveMultilineInput { get; set; }

    /// <summary>When true, the command requires non-empty input; clients should render the input hint as required.</summary>
    [JsonPropertyName("required")]
    public bool? Required { get; set; }
}

/// <summary>Slash-command metadata with name, aliases, description, kind, input hint, execution allowance, and schedulability.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SlashCommandInfo
{
    /// <summary>Canonical aliases without leading slashes.</summary>
    [JsonPropertyName("aliases")]
    public IList<string>? Aliases { get; set; }

    /// <summary>Whether the command may run while an agent turn is active.</summary>
    [JsonPropertyName("allowDuringAgentExecution")]
    public bool AllowDuringAgentExecution { get; set; }

    /// <summary>Human-readable command description.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Whether the command is experimental.</summary>
    [JsonPropertyName("experimental")]
    public bool? Experimental { get; set; }

    /// <summary>Optional unstructured input hint.</summary>
    [JsonPropertyName("input")]
    public SlashCommandInput? Input { get; set; }

    /// <summary>Coarse command category for grouping and behavior: runtime built-in, skill-backed command, or SDK/client-owned command.</summary>
    [JsonPropertyName("kind")]
    public SlashCommandKind Kind { get; set; }

    /// <summary>Canonical command name without a leading slash.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Whether the command may be the target of `/every` / `/after` schedules. Resolution happens at every tick, so only set this when the command is safe to re-invoke and produces an agent prompt.</summary>
    [JsonPropertyName("schedulable")]
    public bool? Schedulable { get; set; }
}

/// <summary>Slash commands available in the session, after applying any include/exclude filters.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CommandList
{
    /// <summary>Commands available in this session.</summary>
    [JsonPropertyName("commands")]
    public IList<SlashCommandInfo> Commands { get => field ??= []; set; }
}

/// <summary>A single user setting's effective value alongside its default, so consumers can render settings left at their default.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UserSettingMetadata
{
    /// <summary>The centrally-known default for this setting (null when no default is registered).</summary>
    [JsonPropertyName("default")]
    public JsonElement Default { get; set; }

    /// <summary>True when the user has not set an explicit value for this setting (i.e. it is left at its default). Reflects whether the user has overridden the key, not whether the effective value happens to equal the default — a key explicitly set to a value identical to the default still reports false.</summary>
    [JsonPropertyName("isDefault")]
    public bool IsDefault { get; set; }

    /// <summary>The effective value: the user's value if set, otherwise the default.</summary>
    [JsonPropertyName("value")]
    public JsonElement Value { get; set; }
}

/// <summary>Per-key metadata for every known user setting (settings.json overlaid with the legacy config.json, config.json wins), including settings left at their default. Excludes repository- and enterprise-managed overrides.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UserSettingsGetResult
{
    /// <summary>Every known user setting keyed by setting name, each with its effective value, default, and whether it is at the default.</summary>
    [JsonPropertyName("settings")]
    public IDictionary<string, UserSettingMetadata> Settings { get => field ??= new Dictionary<string, UserSettingMetadata>(); set; }
}

/// <summary>Outcome of writing user settings.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UserSettingsSetResult
{
    /// <summary>Top-level keys whose write landed in settings.json but is shadowed by a value still present in the legacy config.json (config.json wins on read). The write does not take effect until the legacy value is removed.</summary>
    [JsonPropertyName("shadowedKeys")]
    public IList<string> ShadowedKeys { get => field ??= []; set; }
}

/// <summary>Partial user settings to write to settings.json. Each top-level key is written individually, replacing the existing value; a key whose value is null is removed.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UserSettingsSetRequest
{
    /// <summary>Partial user settings to write, as a free-form object keyed by setting name.</summary>
    [JsonPropertyName("settings")]
    public JsonElement Settings { get; set; }
}

/// <summary>Validated device-managed settings discovered before a session exists.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ManagedSettingsReadResult
{
    /// <summary>Discovery or validation error text when managed settings could not be read safely.</summary>
    [JsonPropertyName("errorMessage")]
    public string? ErrorMessage { get; set; }

    /// <summary>Validated, canonical managed-settings JSON. Omitted when no managed settings were discovered or when discovered settings failed validation.</summary>
    [JsonPropertyName("settingsJson")]
    public JsonElement? SettingsJson { get; set; }
}

/// <summary>Indicates whether the calling client was registered as the session filesystem provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSetProviderResult
{
    /// <summary>Whether the provider was set successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Optional capabilities declared by the provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSetProviderCapabilities
{
    /// <summary>Whether the provider supports SQLite query/exists operations.</summary>
    [JsonPropertyName("sqlite")]
    public bool? Sqlite { get; set; }
}

/// <summary>Initial working directory, session-state path layout, and path conventions used to register the calling SDK client as the session filesystem provider.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionFsSetProviderRequest
{
    /// <summary>Optional capabilities declared by the provider.</summary>
    [JsonPropertyName("capabilities")]
    public SessionFsSetProviderCapabilities? Capabilities { get; set; }

    /// <summary>Path conventions used by this filesystem.</summary>
    [JsonPropertyName("conventions")]
    public SessionFsSetProviderConventions Conventions { get; set; }

    /// <summary>Initial working directory for sessions.</summary>
    [JsonPropertyName("initialCwd")]
    public string InitialCwd { get; set; } = string.Empty;

    /// <summary>Path within each session's SessionFs where the runtime stores files for that session.</summary>
    [JsonPropertyName("sessionStatePath")]
    public string SessionStatePath { get; set; } = string.Empty;
}

/// <summary>Indicates whether the calling client was registered as the LLM inference provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceSetProviderResult
{
    /// <summary>Whether the provider was set successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Whether the start frame was accepted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceHttpResponseStartResult
{
    /// <summary>True when the response start was matched to a pending request; false when unknown.</summary>
    [JsonPropertyName("accepted")]
    public bool Accepted { get; set; }
}

/// <summary>Response head.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class LlmInferenceHttpResponseStartRequest
{
    /// <summary>HTTP response headers, preserving multiple values per name.</summary>
    [JsonPropertyName("headers")]
    public IDictionary<string, IList<string>> Headers { get => field ??= new Dictionary<string, IList<string>>(); set; }

    /// <summary>Matches the requestId from the originating httpRequestStart frame.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>HTTP status code.</summary>
    [JsonPropertyName("status")]
    public long Status { get; set; }

    /// <summary>Optional HTTP status reason phrase.</summary>
    [JsonPropertyName("statusText")]
    public string? StatusText { get; set; }
}

/// <summary>Whether the chunk was accepted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceHttpResponseChunkResult
{
    /// <summary>True when the chunk was matched to a pending request; false when unknown.</summary>
    [JsonPropertyName("accepted")]
    public bool Accepted { get; set; }
}

/// <summary>Set to terminate the response with a transport-level failure. Implies end-of-stream; any further chunks for this requestId are ignored.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceHttpResponseChunkError
{
    /// <summary>Optional machine-readable error code.</summary>
    [JsonPropertyName("code")]
    public string? Code { get; set; }

    /// <summary>Human-readable failure description.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;
}

/// <summary>A response body chunk or terminal error.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class LlmInferenceHttpResponseChunkRequest
{
    /// <summary>When true, `data` is base64-encoded bytes. When absent or false, `data` is UTF-8 text.</summary>
    [JsonPropertyName("binary")]
    public bool? Binary { get; set; }

    /// <summary>Body byte range. UTF-8 text when `binary` is absent or false; base64-encoded bytes when `binary` is true. May be empty (e.g. when the response body is empty: send a single chunk with empty data and end=true).</summary>
    [JsonPropertyName("data")]
    public string Data { get; set; } = string.Empty;

    /// <summary>When true, this is the final body chunk for the response. The runtime treats the response body as complete after receiving an end-marked chunk.</summary>
    [JsonPropertyName("end")]
    public bool? End { get; set; }

    /// <summary>Set to terminate the response with a transport-level failure. Implies end-of-stream; any further chunks for this requestId are ignored.</summary>
    [JsonPropertyName("error")]
    public LlmInferenceHttpResponseChunkError? Error { get; set; }

    /// <summary>Matches the requestId from the originating httpRequestStart frame.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;
}

/// <summary>Pre-resolved working-directory context for session startup.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionContext
{
    /// <summary>Active git branch.</summary>
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Most recent working directory for this session.</summary>
    [JsonPropertyName("cwd")]
    public string Cwd { get; set; } = string.Empty;

    /// <summary>Git repository root, if the cwd was inside a git repo.</summary>
    [JsonPropertyName("gitRoot")]
    public string? GitRoot { get; set; }

    /// <summary>Repository host type.</summary>
    [JsonPropertyName("hostType")]
    public SessionContextHostType? HostType { get; set; }

    /// <summary>Repository slug in `owner/name` form, when known.</summary>
    [JsonPropertyName("repository")]
    public string? Repository { get; set; }
}

/// <summary>GitHub repository the remote session belongs to.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteSessionMetadataRepository
{
    /// <summary>Branch associated with the remote session.</summary>
    [JsonPropertyName("branch")]
    public string Branch { get; set; } = string.Empty;

    /// <summary>Repository name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Repository owner.</summary>
    [JsonPropertyName("owner")]
    public string Owner { get; set; } = string.Empty;
}

/// <summary>Remote session metadata for the session to hand off (typically obtained from `sessions.list` with `source: "remote"`).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteSessionMetadataValue
{
    /// <summary>Most recent working directory context.</summary>
    [JsonPropertyName("context")]
    public SessionContext? Context { get; set; }

    /// <summary>Host-supplied human description of what the session is doing right now ("running tests", "waiting for approval"). Optional in the protocol and absent on hosts that do not publish it, so never rely on it -- it enriches `hostStatus`, it does not replace it.</summary>
    [JsonPropertyName("hostActivity")]
    public string? HostActivity { get; set; }

    /// <summary>Live status as the owning host reports it in its session listing, so a row for a session running elsewhere can show that it is running. Absent for hosts that publish no such status (the cloud task managers), which read as idle.</summary>
    [JsonPropertyName("hostStatus")]
    public RemoteSessionHostStatus? HostStatus { get; set; }

    /// <summary>Always true for remote sessions.</summary>
    [JsonPropertyName("isRemote")]
    public bool IsRemote { get; set; }

    /// <summary>Last-modified time as an ISO 8601 timestamp.</summary>
    [JsonPropertyName("modifiedTime")]
    public string ModifiedTime { get; set; } = string.Empty;

    /// <summary>Optional human-friendly name set via /rename.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Pull request number associated with the session.</summary>
    [JsonPropertyName("pullRequestNumber")]
    public long? PullRequestNumber { get; set; }

    /// <summary>Backing remote session IDs (most recent first).</summary>
    [JsonPropertyName("remoteSessionIds")]
    public IList<string> RemoteSessionIds { get => field ??= []; set; }

    /// <summary>GitHub repository the remote session belongs to.</summary>
    [JsonPropertyName("repository")]
    public RemoteSessionMetadataRepository Repository { get => field ??= new(); set; }

    /// <summary>Original remote resource identifier (task ID or PR node ID).</summary>
    [JsonPropertyName("resourceId")]
    public string? ResourceId { get; set; }

    /// <summary>Stable session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Deadline (ISO 8601) at which a CLI remote session becomes stale without further heartbeats.</summary>
    [JsonPropertyName("staleAt")]
    public string? StaleAt { get; set; }

    /// <summary>Session creation time as an ISO 8601 timestamp.</summary>
    [JsonPropertyName("startTime")]
    public string StartTime { get; set; } = string.Empty;

    /// <summary>Server-side task state returned by GitHub.</summary>
    [JsonPropertyName("state")]
    public string? State { get; set; }

    /// <summary>Short summary of the session, when one has been derived.</summary>
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }

    /// <summary>Whether the remote task originated from CCA or CLI `--remote`.</summary>
    [JsonPropertyName("taskType")]
    public RemoteSessionMetadataTaskType? TaskType { get; set; }
}

/// <summary>`sessions.open` handoff progress update with step, status, and optional message.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsOpenProgress
{
    /// <summary>Optional step message.</summary>
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Step status.</summary>
    [JsonPropertyName("status")]
    public SessionsOpenProgressStatus Status { get; set; }

    /// <summary>Handoff step.</summary>
    [JsonPropertyName("step")]
    public SessionsOpenProgressStep Step { get; set; }
}

/// <summary>Result of opening a session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionOpenResult
{
    /// <summary>Remote session metadata, present when status is `connected`.</summary>
    [JsonPropertyName("metadata")]
    public RemoteSessionMetadataValue? Metadata { get; set; }

    /// <summary>Handoff progress steps, present when status is `handed_off`.</summary>
    [JsonPropertyName("progress")]
    public IList<SessionsOpenProgress>? Progress { get; set; }

    /// <summary>Remote session ID, present when status is `connected`.</summary>
    [JsonPropertyName("remoteSessionId")]
    public string? RemoteSessionId { get; set; }

    /// <summary>Opened session ID. Omitted when status is `not_found`.</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }

    /// <summary>Startup prompts queued by user-level hook configs at session creation. Only populated when status is `created`; resumed sessions return an empty array.</summary>
    [JsonPropertyName("startupPrompts")]
    public IList<string>? StartupPrompts { get; set; }

    /// <summary>Outcome of the open request.</summary>
    [JsonPropertyName("status")]
    public SessionsOpenStatus Status { get; set; }
}

/// <summary>Identifier and optional friendly name assigned to the newly forked session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsForkResult
{
    /// <summary>Friendly name assigned to the forked session, if any.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>The new forked session's ID.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Source session identifier to fork from, optional event-ID boundary, and optional friendly name for the new session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsForkRequest
{
    /// <summary>Optional friendly name to assign to the forked session.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Source session ID to fork from.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional event ID boundary. When provided, the fork includes only events before this ID (exclusive). When omitted, all events are included.</summary>
    [JsonPropertyName("toEventId")]
    public string? ToEventId { get; set; }
}

/// <summary>Repository associated with the connected remote session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ConnectedRemoteSessionMetadataRepository
{
    /// <summary>Branch associated with the remote session.</summary>
    [JsonPropertyName("branch")]
    public string Branch { get; set; } = string.Empty;

    /// <summary>Repository name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Repository owner or organization login.</summary>
    [JsonPropertyName("owner")]
    public string Owner { get; set; } = string.Empty;
}

/// <summary>Metadata for a connected remote session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ConnectedRemoteSessionMetadata
{
    /// <summary>Neutral SDK discriminator for the connected remote session kind.</summary>
    [JsonPropertyName("kind")]
    public ConnectedRemoteSessionMetadataKind Kind { get; set; }

    /// <summary>Last session update time as an ISO 8601 string.</summary>
    [JsonPropertyName("modifiedTime")]
    public DateTimeOffset ModifiedTime { get; set; }

    /// <summary>Optional friendly session name.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Pull request number associated with the session.</summary>
    [JsonPropertyName("pullRequestNumber")]
    public long? PullRequestNumber { get; set; }

    /// <summary>Repository associated with the connected remote session.</summary>
    [JsonPropertyName("repository")]
    public ConnectedRemoteSessionMetadataRepository Repository { get => field ??= new(); set; }

    /// <summary>Original remote resource identifier.</summary>
    [JsonPropertyName("resourceId")]
    public string? ResourceId { get; set; }

    /// <summary>SDK session ID for the connected remote session.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Remote session staleness deadline as an ISO 8601 string.</summary>
    [JsonPropertyName("staleAt")]
    public DateTimeOffset? StaleAt { get; set; }

    /// <summary>Session start time as an ISO 8601 string.</summary>
    [JsonPropertyName("startTime")]
    public DateTimeOffset StartTime { get; set; }

    /// <summary>Remote session state returned by the backing service.</summary>
    [JsonPropertyName("state")]
    public string? State { get; set; }

    /// <summary>Optional session summary.</summary>
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }
}

/// <summary>Remote session connection result.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteSessionConnectionResult
{
    /// <summary>Metadata for a connected remote session.</summary>
    [JsonPropertyName("metadata")]
    public ConnectedRemoteSessionMetadata Metadata { get => field ??= new(); set; }

    /// <summary>SDK session ID for the connected remote session.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Remote session connection parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ConnectRemoteSessionParams
{
    /// <summary>Session ID to connect to.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Local or remote session metadata entry. Narrow on `isRemote` to access source-specific fields.</summary>
/// <remarks>Data type discriminated by <c>isRemote</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SessionListEntry
{
    /// <summary>The boolean discriminator.</summary>
    [JsonPropertyName("isRemote")]
    public bool IsRemote { get; set; }

    /// <summary>Runtime client name that created/last resumed this session.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("clientName")]
    public string? ClientName { get; set; }

    /// <summary>Pre-resolved working-directory context for session startup.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("context")]
    public SessionContext? Context { get; set; }

    /// <summary>Host-supplied human description of what the session is doing right now ("running tests", "waiting for approval"). Optional in the protocol and absent on hosts that do not publish it, so never rely on it -- it enriches `hostStatus`, it does not replace it.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("hostActivity")]
    public string? HostActivity { get; set; }

    /// <summary>Live status as the owning host reports it in its session listing, so a row for a session running elsewhere can show that it is running. Absent for hosts that publish no such status (the cloud task managers), which read as idle.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("hostStatus")]
    public RemoteSessionHostStatus? HostStatus { get; set; }

    /// <summary>True for detached maintenance sessions that should be hidden from normal resume lists.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("isDetached")]
    public bool? IsDetached { get; set; }

    /// <summary>GitHub task ID, when this local session is bound to one. Only present for local sessions exported to remote control.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mcTaskId")]
    public string? McTaskId { get; set; }

    /// <summary>Last-modified time of the session's persisted state, as ISO 8601.</summary>
    [JsonPropertyName("modifiedTime")]
    public required string ModifiedTime { get; set; }

    /// <summary>Optional human-friendly name set via /rename.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Pull request number associated with the session.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pullRequestNumber")]
    public long? PullRequestNumber { get; set; }

    /// <summary>Backing remote session IDs (most recent first).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("remoteSessionIds")]
    public IList<string>? RemoteSessionIds { get; set; }

    /// <summary>GitHub repository the remote session belongs to.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repository")]
    public RemoteSessionMetadataRepository? Repository { get; set; }

    /// <summary>Original remote resource identifier (task ID or PR node ID).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resourceId")]
    public string? ResourceId { get; set; }

    /// <summary>Stable session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }

    /// <summary>Deadline (ISO 8601) at which a CLI remote session becomes stale without further heartbeats.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("staleAt")]
    public string? StaleAt { get; set; }

    /// <summary>Session creation time as an ISO 8601 timestamp.</summary>
    [JsonPropertyName("startTime")]
    public required string StartTime { get; set; }

    /// <summary>Server-side task state returned by GitHub.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("state")]
    public string? State { get; set; }

    /// <summary>Short summary of the session, when one has been derived.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }

    /// <summary>Whether the remote task originated from CCA or CLI `--remote`.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("taskType")]
    public RemoteSessionMetadataTaskType? TaskType { get; set; }
}

/// <summary>Sessions matching the filter, ordered most-recently-modified first.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionList
{
    /// <summary>Sessions ordered most-recently-modified first. Discriminated by `isRemote`.</summary>
    [JsonPropertyName("sessions")]
    public IList<SessionListEntry> Sessions { get => field ??= []; set; }
}

/// <summary>Optional filter applied to the returned sessions.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionListFilter
{
    /// <summary>Match sessions whose context.branch equals this value.</summary>
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Match sessions whose context.cwd equals this value.</summary>
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Match sessions whose context.gitRoot equals this value.</summary>
    [JsonPropertyName("gitRoot")]
    public string? GitRoot { get; set; }

    /// <summary>Match sessions whose context.repository equals this value.</summary>
    [JsonPropertyName("repository")]
    public string? Repository { get; set; }
}

/// <summary>Optional source filter, metadata-load limit, and context filter applied to the returned sessions.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsListRequest
{
    /// <summary>Optional filter applied to the returned sessions.</summary>
    [JsonPropertyName("filter")]
    public SessionListFilter? Filter { get; set; }

    /// <summary>When true, include detached maintenance sessions. Defaults to false for user-facing session lists.</summary>
    [JsonPropertyName("includeDetached")]
    public bool? IncludeDetached { get; set; }

    /// <summary>When provided, only the first N local sessions (sorted by modification time, newest first) load full metadata; remaining sessions return basic info only. Use 0 to return only basic info for every local session. Has no effect on remote entries (which always carry their full shape).</summary>
    [JsonPropertyName("metadataLimit")]
    public long? MetadataLimit { get; set; }

    /// <summary>Which session sources to include. Defaults to `local` for backward compatibility.</summary>
    [JsonPropertyName("source")]
    public SessionSource? Source { get; set; }

    /// <summary>Only meaningful when `source` includes remote. When true, propagates errors from the remote service instead of silently returning an empty remote list. Defaults to false.</summary>
    [JsonPropertyName("throwOnError")]
    public bool? ThrowOnError { get; set; }
}

/// <summary>Persisted local session metadata, including identifiers, timestamps, summary/name, client, context, detached state, and task ID.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LocalSessionMetadataValue
{
    /// <summary>Runtime client name that created/last resumed this session.</summary>
    [JsonPropertyName("clientName")]
    public string? ClientName { get; set; }

    /// <summary>Pre-resolved working-directory context for session startup.</summary>
    [JsonPropertyName("context")]
    public SessionContext? Context { get; set; }

    /// <summary>True for detached maintenance sessions that should be hidden from normal resume lists.</summary>
    [JsonPropertyName("isDetached")]
    public bool? IsDetached { get; set; }

    /// <summary>Always false for local sessions.</summary>
    [JsonPropertyName("isRemote")]
    public bool IsRemote { get; set; }

    /// <summary>GitHub task ID, when this local session is bound to one. Only present for local sessions exported to remote control.</summary>
    [JsonPropertyName("mcTaskId")]
    public string? McTaskId { get; set; }

    /// <summary>Last-modified time of the session's persisted state, as ISO 8601.</summary>
    [JsonPropertyName("modifiedTime")]
    public string ModifiedTime { get; set; } = string.Empty;

    /// <summary>Optional human-friendly name set via /rename.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Stable session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Session creation time as an ISO 8601 timestamp.</summary>
    [JsonPropertyName("startTime")]
    public string StartTime { get; set; } = string.Empty;

    /// <summary>Short summary of the session, when one has been derived.</summary>
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }
}

/// <summary>Persisted local session metadata when the session exists.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetMetadataResult
{
    /// <summary>Local session metadata, omitted when the session does not exist.</summary>
    [JsonPropertyName("session")]
    public LocalSessionMetadataValue? Session { get; set; }
}

/// <summary>Session ID whose persisted metadata should be read.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetMetadataRequest
{
    /// <summary>Session ID to inspect.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Client metadata outcome for one requested local session.</summary>
/// <remarks>Polymorphic base type discriminated by <c>status</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "status",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(SessionsClientMetadataEntryOk), "ok")]
[JsonDerivedType(typeof(SessionsClientMetadataEntryNotFound), "notFound")]
[JsonDerivedType(typeof(SessionsClientMetadataEntryCorrupt), "corrupt")]
[JsonDerivedType(typeof(SessionsClientMetadataEntryUnsupportedVersion), "unsupportedVersion")]
[JsonDerivedType(typeof(SessionsClientMetadataEntryUnavailable), "unavailable")]
public partial class SessionsClientMetadataEntry
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("status")]
    public virtual string Status { get; set; } = string.Empty;
}


/// <summary>The <c>ok</c> variant of <see cref="SessionsClientMetadataEntry"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SessionsClientMetadataEntryOk : SessionsClientMetadataEntry
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "ok";

    /// <summary>Validated client metadata, possibly empty or projected to requested keys.</summary>
    [JsonPropertyName("metadata")]
    public required IDictionary<string, string> Metadata { get; set; }

    /// <summary>Requested session ID.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }
}

/// <summary>The <c>notFound</c> variant of <see cref="SessionsClientMetadataEntry"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SessionsClientMetadataEntryNotFound : SessionsClientMetadataEntry
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "notFound";

    /// <summary>Requested session ID.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }
}

/// <summary>The <c>corrupt</c> variant of <see cref="SessionsClientMetadataEntry"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SessionsClientMetadataEntryCorrupt : SessionsClientMetadataEntry
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "corrupt";

    /// <summary>Requested session ID.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }
}

/// <summary>The <c>unsupportedVersion</c> variant of <see cref="SessionsClientMetadataEntry"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SessionsClientMetadataEntryUnsupportedVersion : SessionsClientMetadataEntry
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "unsupportedVersion";

    /// <summary>Requested session ID.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }
}

/// <summary>The <c>unavailable</c> variant of <see cref="SessionsClientMetadataEntry"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SessionsClientMetadataEntryUnavailable : SessionsClientMetadataEntry
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "unavailable";

    /// <summary>Filesystem or provider error code. Clients should not assume every provider uses operating-system error codes.</summary>
    [JsonPropertyName("code")]
    public required string Code { get; set; }

    /// <summary>Human-readable diagnostic message. Not stable for programmatic matching.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Requested session ID.</summary>
    [JsonPropertyName("sessionId")]
    public required string SessionId { get; set; }
}

/// <summary>Bounded batch request for client-owned metadata from persisted local sessions.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetClientMetadataRequest
{
    /// <summary>Case-sensitive keys to project from each valid bag. Each key must be non-empty, at most 256 UTF-8 bytes, and outside the reserved `copilot/` and `github/` namespaces. Omit to return every entry.</summary>
    [JsonPropertyName("keys")]
    public IList<string>? Keys { get; set; }

    /// <summary>Session IDs to inspect. Results preserve this order.</summary>
    [JsonPropertyName("sessionIds")]
    public IList<string> SessionIds { get => field ??= []; set; }
}

/// <summary>Batch of session events returned by a read, with cursor and continuation metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class EventsReadResult
{
    /// <summary>Opaque cursor for the next read. Pass back unchanged in the next read.cursor to continue from where this read left off. Always present, even when no events were returned. For a backward read this cursor pages toward OLDER events; keep passing `direction: backward` with it (the cursor is also self-describing, so backward paging continues correctly).</summary>
    [JsonPropertyName("cursor")]
    public string Cursor { get; set; } = string.Empty;

    /// <summary>Cursor status: 'ok' means the cursor was applied successfully; 'expired' means the cursor referred to an event that no longer exists in history (e.g. truncated or compacted away) and the read fell back to a boundary of the remaining history. For a forward read the fallback starts from the beginning of the remaining history; for a backward read it falls back to the tail (the newest window). Because the fallback page is a fresh boundary snapshot rather than a continuation of the requested cursor, it may overlap events the consumer has already rendered — a backward fallback to the tail in particular can repeat the newest window. On 'expired', consumers should reset or rebase their local pagination state (or deduplicate by event id) before continuing from the returned cursor rather than blindly appending/prepending the fallback page.</summary>
    [JsonPropertyName("cursorStatus")]
    public EventsCursorStatus CursorStatus { get; set; }

    /// <summary>Session events for this batch, merged into a single stream in creation order: durable (persisted) events and ephemeral events interleave exactly as they were emitted. Set `includeEphemeral: false` to receive only durable events. Ephemeral events are never replayable once pruned from the in-memory ring, so a consumer that needs them should keep reading with a non-zero `waitMs`. For a backward (tail-first) read, the returned window contains persisted events only, still in chronological (oldest-to-newest) append order.</summary>
    [JsonPropertyName("events")]
    public IList<SessionEvent> Events { get => field ??= []; set; }

    /// <summary>True when more events are available in the read's direction. For a forward read, true means the batch returned `max` events and more are available immediately. For a backward read, true means older persisted events remain before the returned window.</summary>
    [JsonPropertyName("hasMore")]
    public bool HasMore { get; set; }
}

/// <summary>Pagination options for reading an inactive or active local session's persisted event journal.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsReadPersistedEventsRequest
{
    /// <summary>Opaque cursor returned by a previous persisted-event read. Omit on the first call.</summary>
    [JsonPropertyName("cursor")]
    public string? Cursor { get; set; }

    /// <summary>Direction to page through persisted history. Forward starts at the beginning; backward starts with the newest events. Events in each page remain chronological.</summary>
    [JsonPropertyName("direction")]
    public EventsReadDirection? Direction { get; set; }

    /// <summary>Maximum number of events to return in this batch (1–1000, default 200).</summary>
    [JsonPropertyName("max")]
    public long? Max { get; set; }

    /// <summary>Session ID whose persisted event journal should be read.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Recent local session IDs that contain user-visible history.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsListNonEmptySessionIdsResult
{
    /// <summary>Session IDs ordered newest-first.</summary>
    [JsonPropertyName("sessionIds")]
    public IList<string> SessionIds { get => field ??= []; set; }
}

/// <summary>Limit for non-empty local session IDs.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsListNonEmptySessionIdsRequest
{
    /// <summary>Maximum number of session IDs to return.</summary>
    [JsonPropertyName("limit")]
    public long? Limit { get; set; }
}

/// <summary>ID of the local session bound to the given GitHub task, or omitted when none.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsFindByTaskIDResult
{
    /// <summary>Omitted when no local session is bound to that GitHub task.</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }
}

/// <summary>GitHub task ID to look up.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsFindByTaskIDRequest
{
    /// <summary>GitHub task ID to look up.</summary>
    [JsonPropertyName("taskId")]
    public string TaskId { get; set; } = string.Empty;
}

/// <summary>Session ID matching the prefix, omitted when no unique match exists.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsFindByPrefixResult
{
    /// <summary>Omitted when no unique session matches the prefix (no match or ambiguous).</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }
}

/// <summary>UUID prefix to resolve to a unique session ID.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsFindByPrefixRequest
{
    /// <summary>UUID prefix (&gt;=7 hex chars, &lt;36 chars). Returns the unique session ID, or undefined when there is no match or the prefix matches multiple sessions.</summary>
    [JsonPropertyName("prefix")]
    public string Prefix { get; set; } = string.Empty;
}

/// <summary>Most-relevant session ID for the supplied context, or omitted when no sessions exist.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsGetLastForContextResult
{
    /// <summary>Most-relevant session ID for the supplied context, or omitted when no sessions exist.</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }
}

/// <summary>Optional working-directory context used to score session relevance.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetLastForContextRequest
{
    /// <summary>Optional working-directory context used to score session relevance. When omitted the most-recently-modified session wins.</summary>
    [JsonPropertyName("context")]
    public SessionContext? Context { get; set; }
}

/// <summary>Absolute path to the session's events.jsonl file on disk.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetEventFilePathResult
{
    /// <summary>Absolute path to the session's events.jsonl file.</summary>
    [JsonPropertyName("filePath")]
    public string FilePath { get; set; } = string.Empty;
}

/// <summary>Session ID whose event-log file path to compute.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetEventFilePathRequest
{
    /// <summary>Session ID whose event-log file path to compute.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Map of sessionId -&gt; on-disk size in bytes for each session's workspace directory.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSizes
{
    /// <summary>Map of sessionId -&gt; on-disk size in bytes for the session's workspace directory.</summary>
    [JsonPropertyName("sizes")]
    public IDictionary<string, long> Sizes { get => field ??= new Dictionary<string, long>(); set; }
}

/// <summary>Session IDs from the input set that are currently in use by another process.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsCheckInUseResult
{
    /// <summary>Session IDs from the input set that are currently held by another running process via an alive lock file.</summary>
    [JsonPropertyName("inUse")]
    public IList<string> InUse { get => field ??= []; set; }
}

/// <summary>Session IDs to test for live in-use locks.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsCheckInUseRequest
{
    /// <summary>Session IDs to test for live in-use locks.</summary>
    [JsonPropertyName("sessionIds")]
    public IList<string> SessionIds { get => field ??= []; set; }
}

/// <summary>The session's persisted remote-steerable flag, or omitted when no value has been persisted.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetPersistedRemoteSteerableResult
{
    /// <summary>The session's persisted remote-steerable flag if recorded; omitted when no value has been persisted.</summary>
    [JsonPropertyName("remoteSteerable")]
    public bool? RemoteSteerable { get; set; }
}

/// <summary>Session ID to look up the persisted remote-steerable flag for.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetPersistedRemoteSteerableRequest
{
    /// <summary>Session ID to look up the persisted remote-steerable flag for.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Closes a session: emits shutdown, flushes pending events to disk, releases the in-use lock, disposes the active session. Idempotent: succeeds even if the session is not currently active.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsCloseResult
{
}

/// <summary>Session ID to close.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsCloseRequest
{
    /// <summary>Session ID to close.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Map of sessionId -&gt; bytes freed by removing the session's workspace directory.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionBulkDeleteResult
{
    /// <summary>Map of sessionId -&gt; bytes freed by removing the session's workspace directory. Sessions whose deletion failed are omitted from this map (failures are logged on the server but not surfaced per-id; check the map for absent IDs to detect them).</summary>
    [JsonPropertyName("freedBytes")]
    public IDictionary<string, long> FreedBytes { get => field ??= new Dictionary<string, long>(); set; }
}

/// <summary>Session IDs to close, deactivate, and delete from disk.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsBulkDeleteRequest
{
    /// <summary>Session IDs to close, deactivate, and delete from disk.</summary>
    [JsonPropertyName("sessionIds")]
    public IList<string> SessionIds { get => field ??= []; set; }
}

/// <summary>Session ID to delete from disk.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsDeleteRequest
{
    /// <summary>Session ID to delete.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Internal resolved session directory path to delete.</summary>
    [JsonPropertyName("sessionPath")]
    public string? SessionPath { get; set; }
}

/// <summary>Outcome of the prune operation: deleted IDs, dry-run candidates, skipped IDs, total bytes freed, and the dry-run flag.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionPruneResult
{
    /// <summary>Session IDs that would be deleted in dry-run mode (always empty otherwise).</summary>
    [JsonPropertyName("candidates")]
    public IList<string> Candidates { get => field ??= []; set; }

    /// <summary>Session IDs that were deleted (always empty in dry-run mode).</summary>
    [JsonPropertyName("deleted")]
    public IList<string> Deleted { get => field ??= []; set; }

    /// <summary>True when no deletions were actually performed.</summary>
    [JsonPropertyName("dryRun")]
    public bool DryRun { get; set; }

    /// <summary>Total bytes freed (actual when not dry-run, projected when dry-run).</summary>
    [JsonPropertyName("freedBytes")]
    public long FreedBytes { get; set; }

    /// <summary>Session IDs that were skipped (e.g., named sessions).</summary>
    [JsonPropertyName("skipped")]
    public IList<string> Skipped { get => field ??= []; set; }
}

/// <summary>Age threshold and optional flags controlling which old sessions are pruned (or simulated when dryRun is true).</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsPruneOldRequest
{
    /// <summary>When true, only report what would be deleted without performing any deletion.</summary>
    [JsonPropertyName("dryRun")]
    public bool? DryRun { get; set; }

    /// <summary>Session IDs that should never be considered for pruning.</summary>
    [JsonPropertyName("excludeSessionIds")]
    public IList<string>? ExcludeSessionIds { get; set; }

    /// <summary>When true, named sessions (set via /rename) are also eligible for pruning.</summary>
    [JsonPropertyName("includeNamed")]
    public bool? IncludeNamed { get; set; }

    /// <summary>Delete sessions whose modifiedTime is at least this many days old.</summary>
    [JsonPropertyName("olderThanDays")]
    public long OlderThanDays { get; set; }
}

/// <summary>Flush a session's pending events to disk. No-op when no writer exists for the session (e.g., already closed).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsSaveResult
{
}

/// <summary>Session ID whose pending events should be flushed to disk.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsSaveRequest
{
    /// <summary>Session ID whose pending events should be flushed to disk.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Release the in-use lock held by this process for the given session. No-op when this process does not currently hold a lock for the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsReleaseLockResult
{
}

/// <summary>Session ID whose in-use lock should be released.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsReleaseLockRequest
{
    /// <summary>Session ID whose in-use lock should be released.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The enriched metadata records, with summary and context fields backfilled where available. Sessions confirmed empty and unnamed are omitted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionEnrichMetadataResult
{
    /// <summary>Enriched records, with summary and context backfilled. Sessions confirmed empty and unnamed may be omitted.</summary>
    [JsonPropertyName("sessions")]
    public IList<LocalSessionMetadataValue> Sessions { get => field ??= []; set; }
}

/// <summary>Session metadata records to enrich with summary and context information.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsEnrichMetadataRequest
{
    /// <summary>Session metadata records to enrich. Records that already have summary and context are returned unchanged.</summary>
    [JsonPropertyName("sessions")]
    public IList<LocalSessionMetadataValue> Sessions { get => field ??= []; set; }
}

/// <summary>Reload all hooks (user, plugin, optionally repo) and apply them to the active session. Call after installing or removing plugins so their hooks take effect immediately. No-op when no active session matches the given sessionId.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsReloadPluginHooksResult
{
}

/// <summary>Active session ID and an optional flag for deferring repo-level hooks until folder trust.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsReloadPluginHooksRequest
{
    /// <summary>When true, skip repo-level hooks. Use before folder trust is confirmed; loadDeferredRepoHooks loads them post-trust.</summary>
    [JsonPropertyName("deferRepoHooks")]
    public bool? DeferRepoHooks { get; set; }

    /// <summary>Active session ID to reload hooks for.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Queued repo-level startup prompts and the total hook command count after loading.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionLoadDeferredRepoHooksResult
{
    /// <summary>Total hook command count (user + plugin + repo) loaded for the session by this call. Captured atomically with startupPrompts so callers don't need to read a separate counter.</summary>
    [JsonPropertyName("hookCount")]
    public long HookCount { get; set; }

    /// <summary>Repo-level startup prompts queued from repo hook configs. Empty on resume, when no repo configs were pending, or when disableAllHooks is set.</summary>
    [JsonPropertyName("startupPrompts")]
    public IList<string> StartupPrompts { get => field ??= []; set; }
}

/// <summary>Active session ID whose deferred repo-level hooks should be loaded.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsLoadDeferredRepoHooksRequest
{
    /// <summary>Active session ID whose deferred repo-level hooks should be loaded.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Replace the manager-wide additional plugins. New session creations and subsequent hook reloads see the new set; already-running sessions keep their existing hook installation until the next reload.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsSetAdditionalPluginsResult
{
}

/// <summary>Installed plugin record from global state, with marketplace, version, install time, enabled state, cache path, and source.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InstalledPlugin
{
    /// <summary>Path where the plugin is cached locally.</summary>
    [JsonPropertyName("cache_path")]
    public string? CachePath { get; set; }

    /// <summary>Whether the plugin is currently enabled.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Installation timestamp.</summary>
    [JsonPropertyName("installed_at")]
    public string InstalledAt { get; set; } = string.Empty;

    /// <summary>Absolute path of the marketplace directory a live plugin was resolved from. Present only on live, never-persisted records — those synthesized at session start for a directory/local marketplace, whose cache_path points at the real plugin directory on disk rather than a copy under the installed-plugins cache. Its presence is what marks a record as live, and no record carrying it is ever written to the persisted installedPlugins key.</summary>
    [JsonPropertyName("installed_from")]
    public string? InstalledFrom { get; set; }

    /// <summary>Marketplace the plugin came from (empty string for direct repo installs).</summary>
    [JsonPropertyName("marketplace")]
    public string Marketplace { get; set; } = string.Empty;

    /// <summary>Plugin name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Source for direct repo installs (when marketplace is empty).</summary>
    [JsonPropertyName("source")]
    public JsonElement? Source { get; set; }

    /// <summary>Per-plugin source fingerprint (a SHA-256 hash of the plugin's catalog source spec plus its resolved source subtree — NOT a Git commit SHA) captured at marketplace install/update time. Auto-update compares it against the freshly recomputed fingerprint to detect a content change that does not bump the version. Absent for pre-existing installs and for direct (non-marketplace) installs.</summary>
    [JsonPropertyName("source_sha")]
    public string? SourceSha { get; set; }

    /// <summary>Version installed (if available).</summary>
    [JsonPropertyName("version")]
    public string? Version { get; set; }
}

/// <summary>Manager-wide additional plugins to register; replaces any previously-configured set.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsSetAdditionalPluginsRequest
{
    /// <summary>Manager-wide additional plugins to register. Replaces any previously-configured set. Pass an empty array to clear.</summary>
    [JsonPropertyName("plugins")]
    public IList<InstalledPlugin> Plugins { get => field ??= []; set; }
}

/// <summary>Dynamic-context board entry count, when available.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetBoardEntryCountResult
{
    /// <summary>Board entry count, when available.</summary>
    [JsonPropertyName("count")]
    public long? Count { get; set; }
}

/// <summary>Session ID whose board entry count should be returned.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsGetBoardEntryCountRequest
{
    /// <summary>Session ID whose board entry count should be returned.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>State of the runtime-managed remote-control singleton.</summary>
/// <remarks>Polymorphic base type discriminated by <c>state</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "state",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(RemoteControlStatusOff), "off")]
[JsonDerivedType(typeof(RemoteControlStatusConnecting), "connecting")]
[JsonDerivedType(typeof(RemoteControlStatusActive), "active")]
[JsonDerivedType(typeof(RemoteControlStatusError), "error")]
public partial class RemoteControlStatus
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("state")]
    public virtual string State { get; set; } = string.Empty;
}


/// <summary>Remote control is not connected.</summary>
/// <remarks>The <c>off</c> variant of <see cref="RemoteControlStatus"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class RemoteControlStatusOff : RemoteControlStatus
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string State => "off";
}

/// <summary>Remote control is in the middle of initial setup.</summary>
/// <remarks>The <c>connecting</c> variant of <see cref="RemoteControlStatus"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class RemoteControlStatusConnecting : RemoteControlStatus
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string State => "connecting";

    /// <summary>Session id the connection is attaching to.</summary>
    [JsonPropertyName("attachedSessionId")]
    public required string AttachedSessionId { get; set; }
}

/// <summary>Remote control is connected to a local session.</summary>
/// <remarks>The <c>active</c> variant of <see cref="RemoteControlStatus"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class RemoteControlStatusActive : RemoteControlStatus
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string State => "active";

    /// <summary>Session id remote control is pointed at.</summary>
    [JsonPropertyName("attachedSessionId")]
    public required string AttachedSessionId { get; set; }

    /// <summary>True while a read-only/session-sync export is deferred, awaiting the first `user.message` before its MC session exists. Marked internal: this field is excluded from the public SDK surface and is populated only on the CLI in-process path.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonInclude]
    [JsonPropertyName("awaitingFirstMessage")]
    internal bool? AwaitingFirstMessage { get; set; }

    /// <summary>MC frontend URL for this session, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("frontendUrl")]
    public string? FrontendUrl { get; set; }

    /// <summary>Whether the MC session may steer this session.</summary>
    [JsonPropertyName("isSteerable")]
    public required bool IsSteerable { get; set; }
}

/// <summary>The last setup attempt failed. The singleton is otherwise off.</summary>
/// <remarks>The <c>error</c> variant of <see cref="RemoteControlStatus"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class RemoteControlStatusError : RemoteControlStatus
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string State => "error";

    /// <summary>Session id the failing setup attempt targeted, when known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("attachedSessionId")]
    public string? AttachedSessionId { get; set; }

    /// <summary>Human-readable error message from the last setup attempt.</summary>
    [JsonPropertyName("error")]
    public required string Error { get; set; }
}

/// <summary>Wrapper for the singleton's current status.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteControlStatusResult
{
    /// <summary>State of the runtime-managed remote-control singleton.</summary>
    [JsonPropertyName("status")]
    public RemoteControlStatus Status { get => field ??= new(); set; }
}

/// <summary>Reattach to an existing MC session without creating a new one.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteControlConfigExistingMcSession
{
    /// <summary>Existing MC session ID to reattach to.</summary>
    [JsonPropertyName("mcSessionId")]
    public string McSessionId { get; set; } = string.Empty;

    /// <summary>Existing MC task ID for the reattached session.</summary>
    [JsonPropertyName("mcTaskId")]
    public string McTaskId { get; set; } = string.Empty;
}

/// <summary>Configuration for the runtime-managed remote-control singleton.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteControlConfig
{
    /// <summary>Reattach to an existing MC session without creating a new one.</summary>
    [JsonPropertyName("existingMcSession")]
    public RemoteControlConfigExistingMcSession? ExistingMcSession { get; set; }

    /// <summary>Whether the user explicitly requested remote (vs. implicit session-sync). Controls warning surfacing for missing-repo cases.</summary>
    [JsonPropertyName("explicit")]
    public bool Explicit { get; set; }

    /// <summary>Whether remote export should be enabled.</summary>
    [JsonPropertyName("remote")]
    public bool Remote { get; set; }

    /// <summary>When true, suppresses timeline messages on successful setup.</summary>
    [JsonPropertyName("silent")]
    public bool Silent { get; set; }

    /// <summary>Whether the MC session may steer the local session (write mode).</summary>
    [JsonPropertyName("steerable")]
    public bool Steerable { get; set; }

    /// <summary>Existing Mission Control task ID to attach the exported session to.</summary>
    [JsonPropertyName("taskId")]
    public string? TaskId { get; set; }
}

/// <summary>Parameters for attaching the remote-control singleton to a session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsStartRemoteControlRequest
{
    /// <summary>Configuration for the runtime-managed remote-control singleton.</summary>
    [JsonPropertyName("config")]
    public RemoteControlConfig Config { get => field ??= new(); set; }

    /// <summary>Local session id to attach remote control to.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Outcome of a transferRemoteControl call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteControlTransferResult
{
    /// <summary>State of the runtime-managed remote-control singleton.</summary>
    [JsonPropertyName("status")]
    public RemoteControlStatus Status { get => field ??= new(); set; }

    /// <summary>Whether the rebinding actually happened.</summary>
    [JsonPropertyName("transferred")]
    public bool Transferred { get; set; }
}

/// <summary>Parameters for atomically rebinding the remote-control singleton.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsTransferRemoteControlRequest
{
    /// <summary>When provided, the transfer is rejected unless the singleton currently points at this session id (compare-and-swap semantics to avoid clobbering newer state).</summary>
    [JsonPropertyName("expectedFromSessionId")]
    public string? ExpectedFromSessionId { get; set; }

    /// <summary>Local session id to point remote control at.</summary>
    [JsonPropertyName("toSessionId")]
    public string ToSessionId { get; set; } = string.Empty;
}

/// <summary>Patch for the singleton's steering state.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsSetRemoteControlSteeringRequest
{
    /// <summary>Target steering state. Today only `true` is actionable on the underlying exporter; `false` is reserved for future use.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }
}

/// <summary>Outcome of a stopRemoteControl call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteControlStopResult
{
    /// <summary>State of the runtime-managed remote-control singleton.</summary>
    [JsonPropertyName("status")]
    public RemoteControlStatus Status { get => field ??= new(); set; }

    /// <summary>Whether the singleton was actually torn down by this call.</summary>
    [JsonPropertyName("stopped")]
    public bool Stopped { get; set; }
}

/// <summary>RPC data type for SessionsStopRemoteControl operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionsStopRemoteControlRequest
{
    /// <summary>When provided, the stop is rejected unless the singleton currently points at this session id (compare-and-swap semantics).</summary>
    [JsonPropertyName("expectedSessionId")]
    public string? ExpectedSessionId { get; set; }

    /// <summary>When true, the singleton is unconditionally torn down regardless of `expectedSessionId`. Use during shutdown or explicit `/remote off`.</summary>
    [JsonPropertyName("force")]
    public bool? Force { get; set; }
}

/// <summary>Handle for releasing the extension tool registration.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class RegisterExtensionToolsResult
{
}

/// <summary>Optional registration options.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionsRegisterExtensionToolsOnSessionOptions
{
}

/// <summary>Params to attach an extension loader's tools to a session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class RegisterExtensionToolsParams
{
    /// <summary>Optional registration options.</summary>
    [JsonPropertyName("options")]
    public SessionsRegisterExtensionToolsOnSessionOptions? Options { get; set; }

    /// <summary>Session to register extension tools on.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Params to attach or detach an in-process ExtensionController delegate.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ConfigureSessionExtensionsParams
{
    /// <summary>Session to attach the extension controller delegate to.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Outcome of an agentRegistry.spawn call.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(AgentRegistrySpawnResultSpawned), "spawned")]
[JsonDerivedType(typeof(AgentRegistrySpawnResultSpawnError), "spawn-error")]
[JsonDerivedType(typeof(AgentRegistrySpawnResultRegistryTimeout), "registry-timeout")]
[JsonDerivedType(typeof(AgentRegistrySpawnResultValidationError), "validation-error")]
public partial class AgentRegistrySpawnResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Full registry entry for the spawned child. Lets the controller call `handleLiveTargetSelected(entry)` directly without re-reading the registry (avoids a TOCTOU window).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentRegistryLiveTargetEntry
{
    /// <summary>Kind of attention required when status === "attention". Meaningful only when status === "attention".</summary>
    [JsonPropertyName("attentionKind")]
    public AgentRegistryLiveTargetEntryAttentionKind? AttentionKind { get; set; }

    /// <summary>Git branch of the session (when known).</summary>
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Copilot CLI version that wrote the entry.</summary>
    [JsonPropertyName("copilotVersion")]
    public string CopilotVersion { get; set; } = string.Empty;

    /// <summary>Working directory of the session (when known).</summary>
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Bind host for the entry's JSON-RPC server.</summary>
    [JsonPropertyName("host")]
    public string Host { get; set; } = string.Empty;

    /// <summary>Process kind tag for the registry entry.</summary>
    [JsonPropertyName("kind")]
    public AgentRegistryLiveTargetEntryKind Kind { get; set; }

    /// <summary>Wall-clock milliseconds since the watcher last observed this entry (heartbeat freshness).</summary>
    [JsonPropertyName("lastSeenMs")]
    public long LastSeenMs { get; set; }

    /// <summary>How the most recent turn ended (clean vs aborted). Lets the renderer distinguish done from done_cancelled.</summary>
    [JsonPropertyName("lastTerminalEvent")]
    public AgentRegistryLiveTargetEntryLastTerminalEvent? LastTerminalEvent { get; set; }

    /// <summary>Model identifier currently selected for the session.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Operating-system pid of the process owning this entry.</summary>
    [JsonPropertyName("pid")]
    public long Pid { get; set; }

    /// <summary>TCP port the entry's JSON-RPC server is listening on.</summary>
    [JsonPropertyName("port")]
    public long Port { get; set; }

    /// <summary>Registry entry schema version (1 = ui-server, 2 = managed-server).</summary>
    [JsonPropertyName("schemaVersion")]
    public long SchemaVersion { get; set; }

    /// <summary>Session ID of the foreground session for this entry.</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }

    /// <summary>Friendly session name (when set).</summary>
    [JsonPropertyName("sessionName")]
    public string? SessionName { get; set; }

    /// <summary>ISO 8601 timestamp captured at registration.</summary>
    [JsonPropertyName("startedAt")]
    public string StartedAt { get; set; } = string.Empty;

    /// <summary>Coarse lifecycle status of the foreground session.</summary>
    [JsonPropertyName("status")]
    public AgentRegistryLiveTargetEntryStatus? Status { get; set; }

    /// <summary>Monotonic per-publisher revision counter incremented on every status update. Lets watchers detect transient flips.</summary>
    [JsonPropertyName("statusRevision")]
    public long? StatusRevision { get; set; }

    /// <summary>Connection token (null when the target is unauthenticated).</summary>
    [JsonInclude]
    [JsonPropertyName("token")]
    internal string? Token { get; set; }
}

/// <summary>Per-spawn log-capture outcome; populated from spawnLiveTarget.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentRegistryLogCapture
{
    /// <summary>Whether per-spawn log capture is on (false when env-disabled or open failed).</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Human-readable open failure message (only set when enabled === false AND the env-disable opt-out was NOT used).</summary>
    [JsonPropertyName("openError")]
    public string? OpenError { get; set; }

    /// <summary>Categorized reason for log-open failure.</summary>
    [JsonPropertyName("openErrorReason")]
    public AgentRegistryLogCaptureOpenErrorReason? OpenErrorReason { get; set; }

    /// <summary>Absolute path to the per-spawn log file (only set when enabled).</summary>
    [JsonPropertyName("path")]
    public string? Path { get; set; }
}

/// <summary>Managed-server child was spawned and registered successfully.</summary>
/// <remarks>The <c>spawned</c> variant of <see cref="AgentRegistrySpawnResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AgentRegistrySpawnResultSpawned : AgentRegistrySpawnResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "spawned";

    /// <summary>Full registry entry for the spawned child. Lets the controller call `handleLiveTargetSelected(entry)` directly without re-reading the registry (avoids a TOCTOU window).</summary>
    [JsonPropertyName("entry")]
    public required AgentRegistryLiveTargetEntry Entry { get; set; }

    /// <summary>If the delegate attempted to send the initial prompt and failed, the categorized error message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("initialPromptError")]
    public string? InitialPromptError { get; set; }

    /// <summary>Whether the delegate already sent the initial prompt. Always omitted in the current wiring: the controller sends the prompt post-attach via the standard LocalRpcSession.send path.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("initialPromptSent")]
    public bool? InitialPromptSent { get; set; }

    /// <summary>Per-spawn log-capture outcome; populated from spawnLiveTarget.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("logCapture")]
    public AgentRegistryLogCapture? LogCapture { get; set; }
}

/// <summary>`child_process.spawn` itself failed before the child entered the registry.</summary>
/// <remarks>The <c>spawn-error</c> variant of <see cref="AgentRegistrySpawnResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AgentRegistrySpawnResultSpawnError : AgentRegistrySpawnResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "spawn-error";

    /// <summary>Underlying errno code (e.g. ENOENT, EACCES) when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("code")]
    public string? Code { get; set; }

    /// <summary>Human-readable error message.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }
}

/// <summary>Spawn succeeded but the child did not publish a matching managed-server entry within the timeout.</summary>
/// <remarks>The <c>registry-timeout</c> variant of <see cref="AgentRegistrySpawnResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AgentRegistrySpawnResultRegistryTimeout : AgentRegistrySpawnResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "registry-timeout";

    /// <summary>Process ID of the orphaned child (so the caller can offer 'kill the pid' guidance).</summary>
    [JsonPropertyName("childPid")]
    public required long ChildPid { get; set; }

    /// <summary>Per-spawn log-capture outcome; populated from spawnLiveTarget.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("logCapture")]
    public AgentRegistryLogCapture? LogCapture { get; set; }
}

/// <summary>Synchronous pre-validation rejected the spawn request.</summary>
/// <remarks>The <c>validation-error</c> variant of <see cref="AgentRegistrySpawnResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class AgentRegistrySpawnResultValidationError : AgentRegistrySpawnResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "validation-error";

    /// <summary>Which parameter field was invalid. Omitted when the rejection is not field-specific.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("field")]
    public AgentRegistrySpawnValidationErrorField? Field { get; set; }

    /// <summary>Human-readable explanation; safe to surface in the UI banner. Never logged to unrestricted telemetry.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Categorized reason for the rejection. Low-cardinality enum so telemetry can aggregate by reason without leaking raw paths or agent/model names.</summary>
    [JsonPropertyName("reason")]
    public required AgentRegistrySpawnValidationErrorReason Reason { get; set; }
}

/// <summary>Inputs to spawn a managed-server child via the controller's spawn delegate.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AgentRegistrySpawnRequest
{
    /// <summary>Custom or built-in agent name (e.g. 'explore'). When omitted, the child uses its own default.</summary>
    [JsonPropertyName("agentName")]
    public string? AgentName { get; set; }

    /// <summary>Working directory for the spawned child (must be an existing directory).</summary>
    [JsonPropertyName("cwd")]
    public string Cwd { get; set; } = string.Empty;

    /// <summary>Optional first user message. Forwarded to the caller (the CLI's spawn wrapper sends it post-attach via the standard LocalRpcSession.send path).</summary>
    [JsonPropertyName("initialPrompt")]
    public string? InitialPrompt { get; set; }

    /// <summary>Model identifier to apply to the new session.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Friendly session name. Must satisfy validateSessionName: non-empty, no leading/trailing whitespace, &lt;=100 chars, no control chars, no double quotes.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Permission posture for the new session. 'yolo' requires the controller-local session to currently be in allow-all mode.</summary>
    [JsonPropertyName("permissionMode")]
    public AgentRegistrySpawnPermissionMode? PermissionMode { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSuspendRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of sending a user message.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SendResult
{
    /// <summary>Unique identifier assigned to the message.</summary>
    [JsonPropertyName("messageId")]
    public string MessageId { get; set; } = string.Empty;
}

/// <summary>Parameters for sending a user message to the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SendRequest
{
    /// <summary>The UI mode the agent was in when this message was sent. Defaults to the session's current mode.</summary>
    [JsonPropertyName("agentMode")]
    public SendAgentMode? AgentMode { get; set; }

    /// <summary>Optional attachments (files, directories, selections, blobs, GitHub references) to include with the message.</summary>
    [JsonPropertyName("attachments")]
    public IList<Attachment>? Attachments { get; set; }

    /// <summary>If false, this message will not trigger a Premium Request Unit charge. User messages default to billable.</summary>
    [JsonPropertyName("billable")]
    public bool? Billable { get; set; }

    /// <summary>If provided, this is shown in the timeline instead of `prompt`.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>How to deliver the message. `enqueue` (default) appends to the message queue. `immediate` interjects during an in-progress turn.</summary>
    [JsonPropertyName("mode")]
    public SendMode? Mode { get; set; }

    /// <summary>If true, adds the message to the front of the queue instead of the end.</summary>
    [JsonPropertyName("prepend")]
    public bool? Prepend { get; set; }

    /// <summary>The user message text.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Custom HTTP headers to include in outbound model requests for this turn. Merged with session-level provider headers; per-turn headers augment and overwrite session-level headers with the same key.</summary>
    [JsonPropertyName("requestHeaders")]
    public IDictionary<string, string>? RequestHeaders { get; set; }

    /// <summary>If set, the request will fail if the named tool is not available when this message is among the user messages at the start of the current exchange.</summary>
    [JsonPropertyName("requiredTool")]
    public string? RequiredTool { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional provenance tag copied to the resulting user.message event. Must be `user`, `system`, `command-&lt;command-id&gt;` for command-originated messages, `schedule-&lt;numeric-id&gt;` for scheduled prompts, or `agent-&lt;agent-id&gt;` for prompts sent by another agent.</summary>
    [RegularExpression("^(user|system|command-.*|schedule-\\d+|agent-.+)$")]
    [JsonInclude]
    [JsonPropertyName("source")]
    internal string? Source { get; set; }

    /// <summary>W3C Trace Context traceparent header for distributed tracing of this agent turn.</summary>
    [JsonPropertyName("traceparent")]
    public string? Traceparent { get; set; }

    /// <summary>W3C Trace Context tracestate header for distributed tracing.</summary>
    [JsonPropertyName("tracestate")]
    public string? Tracestate { get; set; }

    /// <summary>If true, await completion of the agentic loop for this message before returning. Defaults to false (fire-and-forget). When true, the result still contains the same `messageId`; the caller can rely on the agent having processed the message before the call resolves. Transport-dependent tail semantics: on a LOCAL (in-process) session the wait additionally blocks until the completed turn's event tail has been dispatched to this session's in-process subscribers, so a subsequent read of subscriber state already reflects the turn; on a REMOTE session the wait resolves once the loop completes and mirrored delivery follows over the wire. Callers that need the stronger local guarantee on remote sessions should await the event stream explicitly.</summary>
    [JsonPropertyName("wait")]
    public bool? Wait { get; set; }
}

/// <summary>Result of sending zero or more user messages.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SendMessagesResult
{
    /// <summary>Unique identifiers assigned to the messages, one per provided message in order. Empty when no messages were provided.</summary>
    [JsonPropertyName("messageIds")]
    public IList<string> MessageIds { get => field ??= []; set; }
}

/// <summary>A single user message to append to the session as part of a `session.sendMessages` turn.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SendMessageItem
{
    /// <summary>Optional attachments (files, directories, selections, blobs, GitHub references) to include with this message.</summary>
    [JsonPropertyName("attachments")]
    public IList<Attachment>? Attachments { get; set; }

    /// <summary>If false, this message will not trigger a Premium Request Unit charge. User messages default to billable.</summary>
    [JsonInclude]
    [JsonPropertyName("billable")]
    internal bool? Billable { get; set; }

    /// <summary>If provided, this is shown in the timeline instead of `prompt`.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>The user message text.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>If set, the request will fail if the named tool is not available when this message is among the user messages at the start of the current exchange.</summary>
    [JsonPropertyName("requiredTool")]
    public string? RequiredTool { get; set; }

    /// <summary>Optional provenance tag copied to the resulting user.message event. Must be `user`, `system`, `command-&lt;command-id&gt;` for command-originated messages, `schedule-&lt;numeric-id&gt;` for scheduled prompts, or `agent-&lt;agent-id&gt;` for prompts sent by another agent.</summary>
    [RegularExpression("^(user|system|command-.*|schedule-\\d+|agent-.+)$")]
    [JsonInclude]
    [JsonPropertyName("source")]
    internal string? Source { get; set; }
}

/// <summary>Parameters for sending zero or more user messages to the session in a single turn. Remote-backed (Mission Control) sessions do not support this method and will return an error.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SendMessagesRequest
{
    /// <summary>The UI mode the agent was in when these messages were sent. Defaults to the session's current mode.</summary>
    [JsonPropertyName("agentMode")]
    public SendAgentMode? AgentMode { get; set; }

    /// <summary>The user messages to append to the conversation, in order. May be empty, in which case a single turn runs over the existing history with no new user message.</summary>
    [JsonPropertyName("messages")]
    public IList<SendMessageItem> Messages { get => field ??= []; set; }

    /// <summary>How to deliver the messages. `enqueue` (default) appends to the message queue. `immediate` interjects during an in-progress turn.</summary>
    [JsonPropertyName("mode")]
    public SendMode? Mode { get; set; }

    /// <summary>If true, adds the messages to the front of the queue instead of the end.</summary>
    [JsonPropertyName("prepend")]
    public bool? Prepend { get; set; }

    /// <summary>Custom HTTP headers to include in outbound model requests for this turn. Merged with session-level provider headers; per-turn headers augment and overwrite session-level headers with the same key.</summary>
    [JsonPropertyName("requestHeaders")]
    public IDictionary<string, string>? RequestHeaders { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>W3C Trace Context traceparent header for distributed tracing of this agent turn.</summary>
    [JsonPropertyName("traceparent")]
    public string? Traceparent { get; set; }

    /// <summary>W3C Trace Context tracestate header for distributed tracing.</summary>
    [JsonPropertyName("tracestate")]
    public string? Tracestate { get; set; }

    /// <summary>If true, await completion of the agentic loop for this turn before returning. Defaults to false (fire-and-forget). When true, the result still contains the same `messageIds`; the caller can rely on the agent having processed the messages before the call resolves. Transport-dependent tail semantics: on a LOCAL (in-process) session the wait additionally blocks until the completed turn's event tail has been dispatched to this session's in-process subscribers, so a subsequent read of subscriber state already reflects the turn; on a REMOTE session the wait resolves once the loop completes and mirrored delivery follows over the wire. Callers that need the stronger local guarantee on remote sessions should await the event stream explicitly.</summary>
    [JsonPropertyName("wait")]
    public bool? Wait { get; set; }
}

/// <summary>Internal request for sending a system notification.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SendSystemNotificationRequest
{
    /// <summary>Optional structured notification kind.</summary>
    [JsonPropertyName("kind")]
    public JsonElement? Kind { get; set; }

    /// <summary>Notification text to deliver to the model.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>Internal delivery options, including passive policy.</summary>
    [JsonPropertyName("options")]
    public JsonElement? Options { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of aborting the current turn.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AbortResult
{
    /// <summary>Error message if the abort failed.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Whether the abort completed successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Parameters for aborting the current turn.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AbortRequest
{
    /// <summary>Finite reason code describing why the current turn was aborted.</summary>
    [JsonPropertyName("reason")]
    public AbortReason? Reason { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of interrupting the main agent turn.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InterruptMainTurnResult
{
    /// <summary>Whether an in-flight main agent turn was interrupted. False when the main loop was not processing.</summary>
    [JsonPropertyName("interrupted")]
    public bool Interrupted { get; set; }
}

/// <summary>Parameters for interrupting the main agent turn.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class InterruptMainTurnRequest
{
    /// <summary>When true, the user's queued prompts are preserved and run as the next turn once the interrupted turn unwinds; when false (the default), the queue is cleared like a plain abort.</summary>
    [JsonPropertyName("flushQueued")]
    public bool? FlushQueued { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionCancelAllBackgroundAgentsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Parameters for shutting down the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ShutdownRequest
{
    /// <summary>Optional human-readable reason. Typically the message of the error that triggered shutdown when type is 'error'.</summary>
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Why the session is being shut down. Defaults to "routine" when omitted.</summary>
    [JsonPropertyName("type")]
    public ShutdownType? Type { get; set; }
}

/// <summary>Identifier of the session event that was emitted for the log message.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LogResult
{
    /// <summary>The unique identifier of the emitted session event.</summary>
    [JsonPropertyName("eventId")]
    public Guid EventId { get; set; }
}

/// <summary>Message text, optional severity level, persistence flag, optional follow-up URL, and optional tip.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class LogRequest
{
    /// <summary>When true, the message is transient and not persisted to the session event log on disk.</summary>
    [JsonPropertyName("ephemeral")]
    public bool? Ephemeral { get; set; }

    /// <summary>Log severity level. Determines how the message is displayed in the timeline. Defaults to "info".</summary>
    [JsonPropertyName("level")]
    public SessionLogLevel? Level { get; set; }

    /// <summary>Human-readable message.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional actionable tip displayed alongside the message. Only honored on `level: "info"`.</summary>
    [JsonPropertyName("tip")]
    public string? Tip { get; set; }

    /// <summary>Domain category for this log entry (e.g., "mcp", "subscription", "policy", "model"). Maps to `infoType`/`warningType`/`errorType` on the emitted event. Defaults to "notification".</summary>
    [JsonPropertyName("type")]
    public string? Type { get; set; }

    /// <summary>Optional URL the user can open in their browser for more details.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Managed sandbox enforcement state for a session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxEnforcementStatus
{
    /// <summary>Whether an enforcement failure has permanently blocked the session.</summary>
    [JsonPropertyName("blocked")]
    public bool Blocked { get; set; }

    /// <summary>The first sandbox enforcement failure that blocked the session.</summary>
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Whether the effective managed policy requires an available sandbox backend.</summary>
    [JsonPropertyName("required")]
    public bool Required { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSandboxGetEnforcementStatusRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of attempting to disable sandboxing for the current session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxDisableForSessionResult
{
    /// <summary>The authoritative sandbox enabled state after the operation.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Whether this call resolved the pending request and applied the session opt-out.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Optional informational context describing how and where the permission decision was made. This does not affect permission behavior.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionDecisionContext
{
    /// <summary>Disposition of the permission request as observed by the responding client.</summary>
    [JsonPropertyName("outcome")]
    public PermissionDecisionOutcome Outcome { get; set; }

    /// <summary>Whether the responding client could ask a user interactively, was running headlessly, or had no response path. Omit when the client cannot determine this authoritatively.</summary>
    [JsonPropertyName("responseCapability")]
    public PermissionResponseCapability? ResponseCapability { get; set; }

    /// <summary>Controlled reason or actor responsible for the response.</summary>
    [JsonPropertyName("source")]
    public PermissionDecisionSource Source { get; set; }

    /// <summary>Client surface that submitted the response.</summary>
    [JsonPropertyName("surface")]
    public PermissionDecisionSurface Surface { get; set; }
}

/// <summary>Request to disable sandboxing for the current session while resolving an active sandbox-bypass permission prompt.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SandboxDisableForSessionRequest
{
    /// <summary>Optional attribution for the permission decision.</summary>
    [JsonPropertyName("decisionContext")]
    public PermissionDecisionContext? DecisionContext { get; set; }

    /// <summary>Identifier of the exact pending sandbox-bypass permission request that authorized the session opt-out.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Authentication status and account metadata for the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionAuthStatus
{
    /// <summary>Authentication type.</summary>
    [JsonPropertyName("authType")]
    public AuthInfoType? AuthType { get; set; }

    /// <summary>Copilot plan tier (e.g., individual_pro, business).</summary>
    [JsonPropertyName("copilotPlan")]
    public string? CopilotPlan { get; set; }

    /// <summary>Authentication host URL.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("host")]
    public string? Host { get; set; }

    /// <summary>Whether the session has resolved authentication.</summary>
    [JsonPropertyName("isAuthenticated")]
    public bool IsAuthenticated { get; set; }

    /// <summary>Authenticated login/username, if available.</summary>
    [JsonPropertyName("login")]
    public string? Login { get; set; }

    /// <summary>Human-readable authentication status description.</summary>
    [JsonPropertyName("statusMessage")]
    public string? StatusMessage { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionGitHubAuthGetStatusRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the credential update succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSetCredentialsResult
{
    /// <summary>Whether the session ended up with a populated `copilotUser` for the installed credentials. `true` when the supplied credential already carried `copilotUser` or it was successfully re-resolved server-side. `false` when the credential is installed without `copilotUser` — either re-resolution failed, or the variant cannot be re-resolved from the credential alone (only the raw-token variants `token`, `env`, and `gh-cli` can). In both `false` cases the token swap still applied, but plan/quota/billing metadata is degraded. Present whenever a credential was supplied; omitted only when no credential was supplied (no-op call).</summary>
    [JsonPropertyName("copilotUserResolved")]
    public bool? CopilotUserResolved { get; set; }

    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Authentication credentials accepted by session.gitHubAuth.setCredentials. Session-owned token-provider identities cannot be installed through this method.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(SettableAuthInfoHmac), "hmac")]
[JsonDerivedType(typeof(SettableAuthInfoEnv), "env")]
[JsonDerivedType(typeof(SettableAuthInfoToken), "token")]
[JsonDerivedType(typeof(SettableAuthInfoCopilotApiToken), "copilot-api-token")]
[JsonDerivedType(typeof(SettableAuthInfoUser), "user")]
[JsonDerivedType(typeof(SettableAuthInfoGhCli), "gh-cli")]
[JsonDerivedType(typeof(SettableAuthInfoApiKey), "api-key")]
public partial class SettableAuthInfo
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>Authentication-info input variant for GitHub-internal HMAC auth, carrying the public GitHub host and HMAC secret.</summary>
/// <remarks>The <c>hmac</c> variant of <see cref="SettableAuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SettableAuthInfoHmac : SettableAuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "hmac";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>HMAC secret used to sign requests.</summary>
    [JsonPropertyName("hmac")]
    public required string Hmac { get; set; }

    /// <summary>Authentication host. HMAC auth always targets the public GitHub host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }
}

/// <summary>Authentication-info input variant for a token sourced from an environment variable, with host, optional login, token, and env var name.</summary>
/// <remarks>The <c>env</c> variant of <see cref="SettableAuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SettableAuthInfoEnv : SettableAuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "env";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Name of the environment variable the token was sourced from.</summary>
    [JsonPropertyName("envVar")]
    public required string EnvVar { get; set; }

    /// <summary>Authentication host (e.g. https://github.com or a GHES host).</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>User login associated with the token. Undefined for server-to-server tokens (those starting with `ghs_`).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("login")]
    public string? Login { get; set; }

    /// <summary>The token value itself. Treat as a secret.</summary>
    [JsonPropertyName("token")]
    public required string Token { get; set; }
}

/// <summary>Token authentication accepted by session.gitHubAuth.setCredentials.</summary>
/// <remarks>The <c>token</c> variant of <see cref="SettableAuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SettableAuthInfoToken : SettableAuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "token";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>The token value itself. Treat as a secret.</summary>
    [JsonPropertyName("token")]
    public required string Token { get; set; }
}

/// <summary>Authentication-info variant for direct Copilot API token auth sourced from environment variables, with public GitHub host.</summary>
/// <remarks>The <c>copilot-api-token</c> variant of <see cref="SettableAuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SettableAuthInfoCopilotApiToken : SettableAuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "copilot-api-token";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host (always the public GitHub host).</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }
}

/// <summary>Authentication-info variant for OAuth user auth, with host and login; the token remains in the runtime secret store.</summary>
/// <remarks>The <c>user</c> variant of <see cref="SettableAuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SettableAuthInfoUser : SettableAuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "user";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>OAuth user login.</summary>
    [JsonPropertyName("login")]
    public required string Login { get; set; }
}

/// <summary>Authentication-info input variant for GitHub CLI credentials, carrying host, login, and the `gh auth token` value.</summary>
/// <remarks>The <c>gh-cli</c> variant of <see cref="SettableAuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SettableAuthInfoGhCli : SettableAuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "gh-cli";

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }

    /// <summary>User login as reported by `gh auth status`.</summary>
    [JsonPropertyName("login")]
    public required string Login { get; set; }

    /// <summary>The token returned by `gh auth token`. Treat as a secret.</summary>
    [JsonPropertyName("token")]
    public required string Token { get; set; }
}

/// <summary>Authentication-info input variant for API-key authentication to a non-GitHub LLM provider, carrying the secret `apiKey` and host.</summary>
/// <remarks>The <c>api-key</c> variant of <see cref="SettableAuthInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SettableAuthInfoApiKey : SettableAuthInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "api-key";

    /// <summary>The API key. Treat as a secret.</summary>
    [JsonPropertyName("apiKey")]
    public required string ApiKey { get; set; }

    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known. Mirrors the GitHub API `/copilot_internal/v2/token` user response shape — the runtime trusts this verbatim and does not re-fetch when set.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public required string Host { get; set; }
}

/// <summary>New auth credentials to install on the session. Omit to leave credentials unchanged.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSetCredentialsParams
{
    /// <summary>The new auth credentials to install on the session. When omitted or `undefined`, the call is a no-op and the session's existing credentials are preserved. The runtime installs the supplied value immediately for outbound model/API requests. When the credential carries a raw token (`token`, `env`, or `gh-cli`) but no `copilotUser`, the runtime additionally re-resolves `copilotUser` server-side (best-effort, asynchronously, after the synchronous install) so plan/quota/billing metadata regains fidelity; on resolution failure the verbatim credential remains installed. It does NOT otherwise validate the credential. Several variants carry secret material; treat this method's params as containing secrets at rest and in transit.</summary>
    [JsonPropertyName("credentials")]
    public SettableAuthInfo? Credentials { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Credential-free authentication identity safe to expose to hosts and user interfaces.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AuthIdentity
{
    /// <summary>Snapshot of the authenticated user's Copilot subscription info, if known.</summary>
    [JsonPropertyName("copilotUser")]
    public CopilotUserResponse? CopilotUser { get; set; }

    /// <summary>Name of the environment variable that supplied the credential, when applicable.</summary>
    [JsonPropertyName("envVar")]
    public string? EnvVar { get; set; }

    /// <summary>Authentication host.</summary>
    [JsonPropertyName("host")]
    public string Host { get; set; } = string.Empty;

    /// <summary>Authenticated login, when available.</summary>
    [JsonPropertyName("login")]
    public string? Login { get; set; }

    /// <summary>Opaque SDK GitHub credential registration backing this identity. Routing metadata only; never a credential.</summary>
    [JsonPropertyName("registrationId")]
    public string? RegistrationId { get; set; }

    /// <summary>Authentication type.</summary>
    [JsonPropertyName("type")]
    public AuthInfoType Type { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionGitHubAuthGetCurrentAuthInfoRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionGitHubAuthGetAllAuthAvailableRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionGitHubAuthRefreshCopilotUserRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Internal GitHub login parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAuthLoginRequest
{
    /// <summary>GitHub host URL.</summary>
    [JsonPropertyName("host")]
    public string Host { get; set; } = string.Empty;

    /// <summary>GitHub login.</summary>
    [JsonPropertyName("login")]
    public string Login { get; set; } = string.Empty;

    /// <summary>Whether to persist the token after login.</summary>
    [JsonPropertyName("persist")]
    public bool? Persist { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>GitHub authentication token.</summary>
    [JsonPropertyName("token")]
    public string Token { get; set; } = string.Empty;
}

/// <summary>Parameters for switching the session's active authentication.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAuthSwitchRequest
{
    /// <summary>Authentication information to activate.</summary>
    [JsonPropertyName("authInfo")]
    public AuthInfo AuthInfo { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional token paired with the authentication information.</summary>
    [JsonPropertyName("token")]
    public string? Token { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionGitHubAuthLogoutRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Parameters identifying a GitHub authentication to log out.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAuthLogoutUserRequest
{
    /// <summary>Authentication information to log out.</summary>
    [JsonPropertyName("authInfo")]
    public AuthInfo AuthInfo { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Validation error from an authentication attempt.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AuthValidationError
{
    /// <summary>Optional message returned by GitHub.</summary>
    [JsonPropertyName("githubMessage")]
    public string? GitHubMessage { get; set; }

    /// <summary>Authentication validation error message.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionGitHubAuthLastAuthErrorsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A file included in the redacted debug bundle.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DebugCollectLogsCollectedEntry
{
    /// <summary>Relative path of the file in the staged bundle/archive.</summary>
    [JsonPropertyName("bundlePath")]
    public string BundlePath { get; set; } = string.Empty;

    /// <summary>Redacted output size in bytes.</summary>
    [JsonPropertyName("sizeBytes")]
    public long SizeBytes { get; set; }

    /// <summary>Source category for this entry.</summary>
    [JsonPropertyName("source")]
    public DebugCollectLogsSource Source { get; set; }
}

/// <summary>An optional debug bundle entry that could not be included.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DebugCollectLogsSkippedEntry
{
    /// <summary>Relative path requested for this bundle entry.</summary>
    [JsonPropertyName("bundlePath")]
    public string BundlePath { get; set; } = string.Empty;

    /// <summary>Server-local source path that could not be read.</summary>
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>Reason the entry was skipped.</summary>
    [JsonPropertyName("reason")]
    public string Reason { get; set; } = string.Empty;
}

/// <summary>Result of collecting a redacted debug bundle.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DebugCollectLogsResult
{
    /// <summary>Files included in the redacted bundle.</summary>
    [JsonPropertyName("entries")]
    public IList<DebugCollectLogsCollectedEntry> Entries { get => field ??= []; set; }

    /// <summary>Destination kind that was written.</summary>
    [JsonPropertyName("kind")]
    public DebugCollectLogsResultKind Kind { get; set; }

    /// <summary>Actual archive path or staging directory path written. This may differ from the requested path when no-overwrite suffixing or fallback-to-temp-directory was needed.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Optional files or directories that could not be included.</summary>
    [JsonPropertyName("skippedEntries")]
    public IList<DebugCollectLogsSkippedEntry>? SkippedEntries { get; set; }
}

/// <summary>A caller-provided server-local file or directory to include in the debug bundle.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DebugCollectLogsEntry
{
    /// <summary>Relative path to use inside the staged bundle/archive.</summary>
    [JsonPropertyName("bundlePath")]
    public string BundlePath { get; set; } = string.Empty;

    /// <summary>Kind of source path to include.</summary>
    [JsonPropertyName("kind")]
    public DebugCollectLogsEntryKind Kind { get; set; }

    /// <summary>Server-local source path to read.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>How text content from this entry should be redacted. Defaults to plain-text.</summary>
    [JsonPropertyName("redaction")]
    public DebugCollectLogsRedaction? Redaction { get; set; }

    /// <summary>When true, collection fails if this entry cannot be read. Defaults to false, which records the entry in `skippedEntries`.</summary>
    [JsonPropertyName("required")]
    public bool? Required { get; set; }
}

/// <summary>Destination for the redacted debug bundle.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(DebugCollectLogsDestinationArchive), "archive")]
[JsonDerivedType(typeof(DebugCollectLogsDestinationDirectory), "directory")]
public partial class DebugCollectLogsDestination
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>The <c>archive</c> variant of <see cref="DebugCollectLogsDestination"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class DebugCollectLogsDestinationArchive : DebugCollectLogsDestination
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "archive";

    /// <summary>When true, create the archive atomically without overwriting an existing file by appending ` (N)` before the extension as needed. Defaults to false.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("noOverwrite")]
    public bool? NoOverwrite { get; set; }

    /// <summary>Absolute or server-relative path for the .tgz archive to create.</summary>
    [JsonPropertyName("outputPath")]
    public required string OutputPath { get; set; }
}

/// <summary>The <c>directory</c> variant of <see cref="DebugCollectLogsDestination"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class DebugCollectLogsDestinationDirectory : DebugCollectLogsDestination
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "directory";

    /// <summary>Directory where redacted files should be staged. The directory is created if needed.</summary>
    [JsonPropertyName("outputDirectory")]
    public required string OutputDirectory { get; set; }
}

/// <summary>Built-in session diagnostics to include in the bundle. Omitted fields default to true.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DebugCollectLogsInclude
{
    /// <summary>Server-local path to the current process log. When set, it is included as `process.log` and its directory is searched for prior logs from the same session.</summary>
    [JsonPropertyName("currentProcessLogPath")]
    public string? CurrentProcessLogPath { get; set; }

    /// <summary>Include the session event log (`events.jsonl`). Defaults to true.</summary>
    [JsonPropertyName("events")]
    public bool? Events { get; set; }

    /// <summary>Server-local path to the session's events.jsonl file. Internal callers normally omit this and let the runtime derive it from the session.</summary>
    [JsonPropertyName("eventsPath")]
    public string? EventsPath { get; set; }

    /// <summary>Maximum number of previous process logs to include. Defaults to 5.</summary>
    [JsonPropertyName("previousProcessLogLimit")]
    public long? PreviousProcessLogLimit { get; set; }

    /// <summary>Server-local process log directory to search when `currentProcessLogPath` is unavailable, useful for collecting logs for inactive sessions.</summary>
    [JsonPropertyName("processLogDirectory")]
    public string? ProcessLogDirectory { get; set; }

    /// <summary>Include process logs for the session. Defaults to true.</summary>
    [JsonPropertyName("processLogs")]
    public bool? ProcessLogs { get; set; }

    /// <summary>Include interactive shell logs written under the session's `shell-logs` directory. Defaults to true.</summary>
    [JsonPropertyName("shellLogs")]
    public bool? ShellLogs { get; set; }
}

/// <summary>Options for collecting a redacted session debug bundle.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class DebugCollectLogsRequest
{
    /// <summary>Caller-provided server-local files or directories to include in addition to the runtime's built-in session diagnostics. This lets host applications add their own diagnostics without changing the API shape.</summary>
    [JsonPropertyName("additionalEntries")]
    public IList<DebugCollectLogsEntry>? AdditionalEntries { get; set; }

    /// <summary>Where the redacted bundle should be written. Use `archive` to produce a .tgz, or `directory` to stage redacted files for caller-managed upload/post-processing.</summary>
    [JsonPropertyName("destination")]
    public DebugCollectLogsDestination Destination { get => field ??= new(); set; }

    /// <summary>Which built-in session diagnostics to include. Omitted fields default to true.</summary>
    [JsonPropertyName("include")]
    public DebugCollectLogsInclude? Include { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Canvas action that the agent or host can invoke. To discover the input schema for a particular action, call the list_canvas_capabilities tool.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasAction
{
    /// <summary>Description of the action.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>JSON Schema for the action input.</summary>
    [JsonPropertyName("inputSchema")]
    public JsonElement? InputSchema { get; set; }

    /// <summary>Action name exposed by the canvas provider.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Canvas available in the current session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DiscoveredCanvas
{
    /// <summary>Actions the agent or host may invoke on an open instance.</summary>
    [JsonPropertyName("actions")]
    public IList<CanvasAction>? Actions { get; set; }

    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public string CanvasId { get; set; } = string.Empty;

    /// <summary>Short, single-sentence description shown to the agent in canvas catalogs.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Human-readable canvas name.</summary>
    [JsonPropertyName("displayName")]
    public string DisplayName { get; set; } = string.Empty;

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public string ExtensionId { get; set; } = string.Empty;

    /// <summary>Owning extension display name, when available.</summary>
    [JsonPropertyName("extensionName")]
    public string? ExtensionName { get; set; }

    /// <summary>Host-local PNG path for the canvas icon, when supplied.</summary>
    [JsonPropertyName("icon")]
    public string? Icon { get; set; }

    /// <summary>JSON Schema for canvas open input.</summary>
    [JsonPropertyName("inputSchema")]
    public JsonElement? InputSchema { get; set; }
}

/// <summary>Declared canvases available in this session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasList
{
    /// <summary>Declared canvases available in this session.</summary>
    [JsonPropertyName("canvases")]
    public IList<DiscoveredCanvas> Canvases { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionCanvasListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Open canvas instance snapshot.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class OpenCanvasInstance
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public string CanvasId { get; set; } = string.Empty;

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public string ExtensionId { get; set; } = string.Empty;

    /// <summary>Owning extension display name, when available.</summary>
    [JsonPropertyName("extensionName")]
    public string? ExtensionName { get; set; }

    /// <summary>Host-local PNG path for the canvas icon, when supplied.</summary>
    [JsonPropertyName("icon")]
    public string? Icon { get; set; }

    /// <summary>Input supplied when the instance was opened.</summary>
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Stable caller-supplied canvas instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public string InstanceId { get; set; } = string.Empty;

    /// <summary>Provider-supplied status text.</summary>
    [JsonPropertyName("status")]
    public string? Status { get; set; }

    /// <summary>Rendered title.</summary>
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>URL for web-rendered canvases.</summary>
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Live open-canvas snapshot.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasListOpenResult
{
    /// <summary>Currently open canvas instances.</summary>
    [JsonPropertyName("openCanvases")]
    public IList<OpenCanvasInstance> OpenCanvases { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionCanvasListOpenRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Canvas open parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CanvasOpenRequest
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public string CanvasId { get; set; } = string.Empty;

    /// <summary>Owning provider identifier. Optional when the canvasId is unique across providers; required to disambiguate when multiple providers register the same canvasId.</summary>
    [JsonPropertyName("extensionId")]
    public string? ExtensionId { get; set; }

    /// <summary>Canvas open input.</summary>
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Caller-supplied stable instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public string InstanceId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Canvas close parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CanvasCloseRequest
{
    /// <summary>Open canvas instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public string InstanceId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Canvas action invocation result.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasActionInvokeResult
{
    /// <summary>Provider-supplied action result.</summary>
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }
}

/// <summary>Canvas action invocation parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CanvasActionInvokeRequest
{
    /// <summary>Action name to invoke.</summary>
    [JsonPropertyName("actionName")]
    public string ActionName { get; set; } = string.Empty;

    /// <summary>Action input.</summary>
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Open canvas instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public string InstanceId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Internal canvas provider registration parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CanvasProviderRegisterRequest
{
    /// <summary>Canvas contributions supplied by the provider.</summary>
    [JsonPropertyName("canvases")]
    public IList<JsonElement> Canvases { get => field ??= []; set; }

    /// <summary>Connection identifier for callback routing.</summary>
    [JsonPropertyName("connectionId")]
    public string ConnectionId { get; set; } = string.Empty;

    /// <summary>Provider metadata supplied by the host.</summary>
    [JsonPropertyName("info")]
    public JsonElement Info { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Internal canvas provider unregistration parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CanvasProviderUnregisterRequest
{
    /// <summary>Connection identifier to unregister.</summary>
    [JsonPropertyName("connectionId")]
    public string ConnectionId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Machine-readable factory run failure.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(FactoryRunFailureFactoryLimitReached), "factory_limit_reached")]
[JsonDerivedType(typeof(FactoryRunFailureFactoryResumeDeclined), "factory_resume_declined")]
[JsonDerivedType(typeof(FactoryRunFailureFactoryDurableFailure), "factory_durable_failure")]
[JsonDerivedType(typeof(FactoryRunFailureFactoryAccountingIncomplete), "factory_accounting_incomplete")]
[JsonDerivedType(typeof(FactoryRunFailureFactoryProviderDisconnected), "factory_provider_disconnected")]
public partial class FactoryRunFailure
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>The <c>factory_limit_reached</c> variant of <see cref="FactoryRunFailure"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class FactoryRunFailureFactoryLimitReached : FactoryRunFailure
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory_limit_reached";

    /// <summary>Resource ceiling that stopped the run.</summary>
    [JsonPropertyName("kind")]
    public required FactoryRunFailureKind Kind { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }

    /// <summary>Suggested larger ceiling when the runtime can derive one safely.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("suggestedValue")]
    public double? SuggestedValue { get; set; }

    /// <summary>Approved effective ceiling that was reached.</summary>
    [JsonPropertyName("value")]
    public required double Value { get; set; }
}

/// <summary>The <c>factory_resume_declined</c> variant of <see cref="FactoryRunFailure"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class FactoryRunFailureFactoryResumeDeclined : FactoryRunFailure
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory_resume_declined";

    /// <summary>Human-readable reason the resume did not proceed.</summary>
    [JsonPropertyName("reason")]
    public required string Reason { get; set; }

    /// <summary>Factory run identifier whose changed limits were declined.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }
}

/// <summary>The <c>factory_durable_failure</c> variant of <see cref="FactoryRunFailure"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class FactoryRunFailureFactoryDurableFailure : FactoryRunFailure
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory_durable_failure";

    /// <summary>Stable failure code.</summary>
    [JsonPropertyName("code")]
    public required string Code { get; set; }

    /// <summary>Execution-critical durable operation that failed.</summary>
    [JsonPropertyName("operation")]
    public required FactoryDurableOperation Operation { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }
}

/// <summary>The run stopped because its usage accounting could not be completed.</summary>
/// <remarks>The <c>factory_accounting_incomplete</c> variant of <see cref="FactoryRunFailure"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class FactoryRunFailureFactoryAccountingIncomplete : FactoryRunFailure
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory_accounting_incomplete";

    /// <summary>Confirmed usage in nano-AIU, representing the floor of what the run spent.</summary>
    [JsonPropertyName("drainedNanoAiu")]
    public required long DrainedNanoAiu { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }
}

/// <summary>The extension that owns the factory disconnected while the run was executing, so the host halted it. The run's journaled subagent results are preserved so a resume can reuse them.</summary>
/// <remarks>The <c>factory_provider_disconnected</c> variant of <see cref="FactoryRunFailure"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class FactoryRunFailureFactoryProviderDisconnected : FactoryRunFailure
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "factory_provider_disconnected";

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public required string RunId { get; set; }
}

/// <summary>Durable metadata describing who initiated a factory pause.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(FactoryPauseInfoUser), "user")]
[JsonDerivedType(typeof(FactoryPauseInfoCheckpoint), "checkpoint")]
public partial class FactoryPauseInfo
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>The <c>user</c> variant of <see cref="FactoryPauseInfo"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class FactoryPauseInfoUser : FactoryPauseInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "user";
}

/// <summary>The <c>checkpoint</c> variant of <see cref="FactoryPauseInfo"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class FactoryPauseInfoCheckpoint : FactoryPauseInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "checkpoint";

    /// <summary>Stable author-defined checkpoint key that initiated the pause.</summary>
    [JsonPropertyName("key")]
    public required string Key { get; set; }
}

/// <summary>Complete current or terminal factory run envelope.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryRunResult
{
    /// <summary>One-based execution attempt represented by this envelope. Absent before the first attempt starts or when returned by an older runtime.</summary>
    [JsonPropertyName("attempt")]
    public long? Attempt { get; set; }

    /// <summary>Error message for an errored run.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Machine-readable failure details for a halted or errored run.</summary>
    [JsonPropertyName("failure")]
    public FactoryRunFailure? Failure { get; set; }

    /// <summary>Structured pause initiator metadata for a paused attempt.</summary>
    [JsonPropertyName("pauseInfo")]
    public FactoryPauseInfo? PauseInfo { get; set; }

    /// <summary>Reason for a halted or cancelled run.</summary>
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Completed factory result.</summary>
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Partial journal and progress snapshot for a halted, cancelled, or errored run.</summary>
    [JsonPropertyName("snapshot")]
    public JsonElement? Snapshot { get; set; }

    /// <summary>Current or terminal factory run status.</summary>
    [JsonPropertyName("status")]
    public FactoryRunStatus Status { get; set; }
}

/// <summary>Wire-only per-invocation factory resource ceiling overrides.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryRunLimits
{
    /// <summary>Maximum AI credits consumed by factory subagents and their descendants. The post-paid ceiling is soft: parallel turns can settle beyond it before the run stops.</summary>
    [JsonPropertyName("maxAiCredits")]
    public double? MaxAiCredits { get; set; }

    /// <summary>Maximum number of factory subagents that may run concurrently.</summary>
    [JsonPropertyName("maxConcurrentSubagents")]
    public long? MaxConcurrentSubagents { get; set; }

    /// <summary>Maximum total number of factory subagents that may be admitted.</summary>
    [JsonPropertyName("maxTotalSubagents")]
    public long? MaxTotalSubagents { get; set; }

    /// <summary>Maximum accumulated active-execution time in seconds. Active execution includes the entire extension body, subprocess waits, queued-agent waits, and sleeps; time between resumed attempts is not counted.</summary>
    [JsonPropertyName("timeoutSeconds")]
    public double? TimeoutSeconds { get; set; }
}

/// <summary>Options controlling factory invocation.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RunOptions
{
    /// <summary>Per-invocation resource ceiling overrides.</summary>
    [JsonPropertyName("limits")]
    public FactoryRunLimits? Limits { get; set; }

    /// <summary>Whether to emit factory phase names to the session transcript.</summary>
    [JsonPropertyName("logPhaseNames")]
    public bool? LogPhaseNames { get; set; }

    /// <summary>Whether to notify the originating session when the factory completes.</summary>
    [JsonPropertyName("notifyOnComplete")]
    public bool? NotifyOnComplete { get; set; }

    /// <summary>Run identifier whose journal and progress should seed this resumed run.</summary>
    [JsonPropertyName("resumeFromRunId")]
    public string? ResumeFromRunId { get; set; }
}

/// <summary>Parameters for invoking a registered factory.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryRunRequest
{
    /// <summary>Factory input value.</summary>
    [JsonPropertyName("args")]
    public JsonElement Args { get; set; }

    /// <summary>Registered factory name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Factory invocation options.</summary>
    [JsonPropertyName("options")]
    public RunOptions? Options { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Resolved persisted factory identity and resumed run envelope.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryResumeResult
{
    /// <summary>Persisted factory name resolved for the resumed run.</summary>
    [JsonPropertyName("factoryName")]
    public string FactoryName { get; set; } = string.Empty;

    /// <summary>Terminal resumed run envelope.</summary>
    [JsonPropertyName("run")]
    public FactoryRunResult Run { get => field ??= new(); set; }
}

/// <summary>Parameters for resuming a factory run from its persisted identity.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryResumeRequest
{
    /// <summary>Optional per-invocation resource ceiling overrides.</summary>
    [JsonPropertyName("limits")]
    public FactoryRunLimits? Limits { get; set; }

    /// <summary>Whether to emit factory phase names to the session transcript.</summary>
    [JsonPropertyName("logPhaseNames")]
    public bool? LogPhaseNames { get; set; }

    /// <summary>Whether to notify the originating session when the factory completes.</summary>
    [JsonPropertyName("notifyOnComplete")]
    public bool? NotifyOnComplete { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Options for an internal tool-originated factory invocation.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryToolRunOptions
{
    /// <summary>Per-invocation resource ceiling overrides.</summary>
    [JsonPropertyName("limits")]
    public FactoryRunLimits? Limits { get; set; }

    /// <summary>Run identifier whose journal and progress should seed this resumed run.</summary>
    [JsonPropertyName("resumeFromRunId")]
    public string? ResumeFromRunId { get; set; }
}

/// <summary>Internal parameters for invoking a registered factory from a tool.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryToolRunRequest
{
    /// <summary>Factory input value.</summary>
    [JsonPropertyName("args")]
    public JsonElement Args { get; set; }

    /// <summary>Registered factory name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Tool-originated factory invocation options.</summary>
    [JsonPropertyName("options")]
    public FactoryToolRunOptions? Options { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Opaque identifier of the originating tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Internal parameters for resuming a factory run from a tool.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryToolResumeRequest
{
    /// <summary>Optional per-invocation resource ceiling overrides.</summary>
    [JsonPropertyName("limits")]
    public FactoryRunLimits? Limits { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Opaque identifier of the originating tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Parameters for retrieving a factory run.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryGetRunRequest
{
    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Declared or approved factory resource ceilings.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryDeclaredLimits
{
    /// <summary>Maximum AI credits consumed by subagents and descendants.</summary>
    [JsonPropertyName("maxAiCredits")]
    public double? MaxAiCredits { get; set; }

    /// <summary>Maximum concurrently active subagents.</summary>
    [JsonPropertyName("maxConcurrentSubagents")]
    public long? MaxConcurrentSubagents { get; set; }

    /// <summary>Maximum total subagents spawned by the run.</summary>
    [JsonPropertyName("maxTotalSubagents")]
    public long? MaxTotalSubagents { get; set; }

    /// <summary>Maximum accumulated active execution time in seconds.</summary>
    [JsonPropertyName("timeoutSeconds")]
    public double? TimeoutSeconds { get; set; }
}

/// <summary>Durable factory resource consumption.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryRunConsumed
{
    /// <summary>Accumulated active execution time in milliseconds.</summary>
    [JsonPropertyName("activeMs")]
    public long ActiveMs { get; set; }

    /// <summary>AI usage consumed by the run in nano-AIU.</summary>
    [JsonPropertyName("nanoAiu")]
    public long NanoAiu { get; set; }

    /// <summary>Total subagents spawned by the run.</summary>
    [JsonPropertyName("subagents")]
    public long Subagents { get; set; }
}

/// <summary>Current factory phase identity.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryCurrentPhase
{
    /// <summary>Current phase identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Zero-based declared phase ordinal, or null for an undeclared phase.</summary>
    [JsonPropertyName("ordinal")]
    public long? Ordinal { get; set; }
}

/// <summary>Prompt-safe terminal factory outcome.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryRunTerminal
{
    /// <summary>Human-readable terminal error.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Machine-readable terminal failure.</summary>
    [JsonPropertyName("failure")]
    public FactoryRunFailure? Failure { get; set; }

    /// <summary>Pause initiator metadata, or null when the run did not pause.</summary>
    [JsonPropertyName("pauseInfo")]
    public FactoryPauseInfo? PauseInfo { get; set; }

    /// <summary>Human-readable terminal reason.</summary>
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Prompt-safe preview of the completed result.</summary>
    [JsonPropertyName("resultPreview")]
    public string? ResultPreview { get; set; }
}

/// <summary>Durable factory run summary with read-time live overlays.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryRunSummary
{
    /// <summary>Epoch milliseconds when the current active segment started, or null while inactive.</summary>
    [JsonPropertyName("activeSegmentStartedAt")]
    public long? ActiveSegmentStartedAt { get; set; }

    /// <summary>Approved effective resource ceilings, or null until approved.</summary>
    [JsonPropertyName("approved")]
    public FactoryDeclaredLimits? Approved { get; set; }

    /// <summary>Whether the durable run state currently passes runtime resume eligibility checks.</summary>
    [JsonPropertyName("canResume")]
    public bool CanResume { get; set; }

    /// <summary>Epoch milliseconds when the run completed, or null while nonterminal.</summary>
    [JsonPropertyName("completedAt")]
    public long? CompletedAt { get; set; }

    /// <summary>Durable resource consumption.</summary>
    [JsonPropertyName("consumed")]
    public FactoryRunConsumed Consumed { get => field ??= new(); set; }

    /// <summary>Epoch milliseconds when the run was created.</summary>
    [JsonPropertyName("createdAt")]
    public long CreatedAt { get; set; }

    /// <summary>Current phase identity, or null before any phase is entered.</summary>
    [JsonPropertyName("currentPhase")]
    public FactoryCurrentPhase? CurrentPhase { get; set; }

    /// <summary>Resource ceilings declared by the factory.</summary>
    [JsonPropertyName("declaredLimits")]
    public FactoryDeclaredLimits DeclaredLimits { get => field ??= new(); set; }

    /// <summary>Number of phases declared by the factory.</summary>
    [JsonPropertyName("declaredPhaseCount")]
    public long DeclaredPhaseCount { get; set; }

    /// <summary>Human-readable factory description.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Registered factory name.</summary>
    [JsonPropertyName("factoryName")]
    public string FactoryName { get; set; } = string.Empty;

    /// <summary>Number of direct factory agents currently live.</summary>
    [JsonPropertyName("liveAgentCount")]
    public long LiveAgentCount { get; set; }

    /// <summary>Epoch milliseconds when this live-overlay snapshot was observed.</summary>
    [JsonPropertyName("observedAt")]
    public long ObservedAt { get; set; }

    /// <summary>Monotonic durable run revision.</summary>
    [JsonPropertyName("revision")]
    public long Revision { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Epoch milliseconds when execution first started, or null before start.</summary>
    [JsonPropertyName("startedAt")]
    public long? StartedAt { get; set; }

    /// <summary>Current factory run status.</summary>
    [JsonPropertyName("status")]
    public FactoryRunStatus Status { get; set; }

    /// <summary>Terminal run outcome, or null while nonterminal.</summary>
    [JsonPropertyName("terminal")]
    public FactoryRunTerminal? Terminal { get; set; }

    /// <summary>Total direct factory agents spawned across all attempts.</summary>
    [JsonPropertyName("totalSpawnedAgentCount")]
    public long TotalSpawnedAgentCount { get; set; }

    /// <summary>Epoch milliseconds when the durable run was last updated.</summary>
    [JsonPropertyName("updatedAt")]
    public long UpdatedAt { get; set; }
}

/// <summary>A page of factory runs in durable creation order.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryListRunsResult
{
    /// <summary>Whether terminal runs newer than this page exist.</summary>
    [JsonPropertyName("hasMoreNewer")]
    public bool? HasMoreNewer { get; set; }

    /// <summary>Newest terminal-run cursor in this page, or null when the terminal window is empty.</summary>
    [JsonPropertyName("newestSeq")]
    public long? NewestSeq { get; set; }

    /// <summary>Oldest terminal-run cursor in this page, or null when the terminal window is empty.</summary>
    [JsonPropertyName("oldestSeq")]
    public long? OldestSeq { get; set; }

    /// <summary>Number of terminal runs older than this page.</summary>
    [JsonPropertyName("omittedOlder")]
    public long? OmittedOlder { get; set; }

    /// <summary>Factory run summaries in durable creation order.</summary>
    [JsonPropertyName("runs")]
    public IList<FactoryRunSummary> Runs { get => field ??= []; set; }
}

/// <summary>Parameters for paging factory runs.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryListRunsRequest
{
    /// <summary>Exclusive forward cursor.</summary>
    [JsonPropertyName("afterSeq")]
    public long? AfterSeq { get; set; }

    /// <summary>Exclusive backward cursor.</summary>
    [JsonPropertyName("beforeSeq")]
    public long? BeforeSeq { get; set; }

    /// <summary>Maximum terminal runs to return. Defaults to 200 and is capped at 500.</summary>
    [JsonPropertyName("limit")]
    public int? Limit { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Prompt-safe durable identity and live status for a direct factory agent.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryAgentSummary
{
    /// <summary>Accumulated active agent time in milliseconds.</summary>
    [JsonPropertyName("activeMs")]
    public long ActiveMs { get; set; }

    /// <summary>Prompt-safe live activity text.</summary>
    [JsonPropertyName("activity")]
    public string? Activity { get; set; }

    /// <summary>Stable direct-agent identifier.</summary>
    [JsonPropertyName("agentId")]
    public string AgentId { get; set; } = string.Empty;

    /// <summary>Registered agent type.</summary>
    [JsonPropertyName("agentType")]
    public string AgentType { get; set; } = string.Empty;

    /// <summary>Epoch milliseconds when the agent completed.</summary>
    [JsonPropertyName("completedAt")]
    public long? CompletedAt { get; set; }

    /// <summary>Friendly, non-unique name intended for display.</summary>
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>Friendly, non-unique name intended for display.</summary>
    [JsonPropertyName("label")]
    public string Label { get; set; } = string.Empty;

    /// <summary>Phase identifier active when the agent was launched, or null.</summary>
    [JsonPropertyName("phaseId")]
    public string? PhaseId { get; set; }

    /// <summary>Model requested when the agent was launched.</summary>
    [JsonPropertyName("requestedModel")]
    public string? RequestedModel { get; set; }

    /// <summary>Concrete model resolved for the agent.</summary>
    [JsonPropertyName("resolvedModel")]
    public string? ResolvedModel { get; set; }

    /// <summary>Owning factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Epoch milliseconds when the agent started.</summary>
    [JsonPropertyName("startedAt")]
    public long? StartedAt { get; set; }

    /// <summary>Current durable or live agent status.</summary>
    [JsonPropertyName("status")]
    public string Status { get; set; } = string.Empty;

    /// <summary>Tool-call identifier that launched the agent.</summary>
    [JsonPropertyName("toolCallId")]
    public string ToolCallId { get; set; } = string.Empty;
}

/// <summary>Durable lifecycle and timing for one factory phase.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryPhaseObservation
{
    /// <summary>Completed active time accumulated by this phase in milliseconds.</summary>
    [JsonPropertyName("accumulatedActiveMs")]
    public long AccumulatedActiveMs { get; set; }

    /// <summary>Epoch milliseconds when this phase completed; for a skipped phase, the synthetic skip timestamp (equal to `startedAt`).</summary>
    [JsonPropertyName("completedAt")]
    public long? CompletedAt { get; set; }

    /// <summary>Current live active time for this phase in milliseconds.</summary>
    [JsonPropertyName("currentActiveMs")]
    public long CurrentActiveMs { get; set; }

    /// <summary>Optional human-readable phase detail.</summary>
    [JsonPropertyName("detail")]
    public string? Detail { get; set; }

    /// <summary>Number of times execution entered this phase.</summary>
    [JsonPropertyName("entryCount")]
    public long EntryCount { get; set; }

    /// <summary>Phase identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Most recent run attempt that entered this phase, or `0` if the phase has never been entered.</summary>
    [JsonPropertyName("lastEnteredRunAttempt")]
    public long LastEnteredRunAttempt { get; set; }

    /// <summary>Direct agents in this phase that are currently live.</summary>
    [JsonPropertyName("liveAgentCount")]
    public long LiveAgentCount { get; set; }

    /// <summary>Zero-based declared phase ordinal, or null for an undeclared phase.</summary>
    [JsonPropertyName("ordinal")]
    public long? Ordinal { get; set; }

    /// <summary>Epoch milliseconds when this phase first started; for a skipped phase, the synthetic skip timestamp (equal to `completedAt`).</summary>
    [JsonPropertyName("startedAt")]
    public long? StartedAt { get; set; }

    /// <summary>Derived lifecycle state of the phase.</summary>
    [JsonPropertyName("status")]
    public FactoryPhaseStatus Status { get; set; }

    /// <summary>Human-readable phase title.</summary>
    [JsonPropertyName("title")]
    public string Title { get; set; } = string.Empty;

    /// <summary>Total direct agents associated with this phase.</summary>
    [JsonPropertyName("totalAgentCount")]
    public long TotalAgentCount { get; set; }
}

/// <summary>One durable factory progress record.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryProgressLine
{
    /// <summary>Resume attempt that emitted this record.</summary>
    [JsonPropertyName("attempt")]
    public long Attempt { get; set; }

    /// <summary>Progress record kind.</summary>
    [JsonPropertyName("kind")]
    public FactoryLogLineKind Kind { get; set; }

    /// <summary>Phase active when the record was emitted, or null before any phase.</summary>
    [JsonPropertyName("phaseId")]
    public string? PhaseId { get; set; }

    /// <summary>Epoch milliseconds when the record was persisted.</summary>
    [JsonPropertyName("recordedAt")]
    public long RecordedAt { get; set; }

    /// <summary>Global monotonic sequence number within the run.</summary>
    [JsonPropertyName("seq")]
    public long Seq { get; set; }

    /// <summary>Prompt-safe progress text.</summary>
    [JsonPropertyName("text")]
    public string Text { get; set; } = string.Empty;
}

/// <summary>A bidirectional page of factory progress.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryProgressPage
{
    /// <summary>Whether progress records newer than this page exist.</summary>
    [JsonPropertyName("hasMoreNewer")]
    public bool HasMoreNewer { get; set; }

    /// <summary>Whether progress records older than this page exist.</summary>
    [JsonPropertyName("hasMoreOlder")]
    public bool HasMoreOlder { get; set; }

    /// <summary>Newest sequence number in this page, or null when empty.</summary>
    [JsonPropertyName("newestSeq")]
    public long? NewestSeq { get; set; }

    /// <summary>Oldest sequence number in this page, or null when empty.</summary>
    [JsonPropertyName("oldestSeq")]
    public long? OldestSeq { get; set; }

    /// <summary>Progress records in sequence order.</summary>
    [JsonPropertyName("records")]
    public IList<FactoryProgressLine> Records { get => field ??= []; set; }

    /// <summary>Run revision reflected by this page.</summary>
    [JsonPropertyName("revision")]
    public long Revision { get; set; }
}

/// <summary>Full factory run observability detail.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryRunDetail
{
    /// <summary>Epoch milliseconds when the current active segment started, or null while inactive.</summary>
    [JsonPropertyName("activeSegmentStartedAt")]
    public long? ActiveSegmentStartedAt { get; set; }

    /// <summary>Durable identities and live statuses for direct factory agents.</summary>
    [JsonPropertyName("agents")]
    public IList<FactoryAgentSummary> Agents { get => field ??= []; set; }

    /// <summary>Approved effective resource ceilings, or null until approved.</summary>
    [JsonPropertyName("approved")]
    public FactoryDeclaredLimits? Approved { get; set; }

    /// <summary>Whether the durable run state currently passes runtime resume eligibility checks.</summary>
    [JsonPropertyName("canResume")]
    public bool CanResume { get; set; }

    /// <summary>Epoch milliseconds when the run completed, or null while nonterminal.</summary>
    [JsonPropertyName("completedAt")]
    public long? CompletedAt { get; set; }

    /// <summary>Durable resource consumption.</summary>
    [JsonPropertyName("consumed")]
    public FactoryRunConsumed Consumed { get => field ??= new(); set; }

    /// <summary>Epoch milliseconds when the run was created.</summary>
    [JsonPropertyName("createdAt")]
    public long CreatedAt { get; set; }

    /// <summary>Current phase identity, or null before any phase is entered.</summary>
    [JsonPropertyName("currentPhase")]
    public FactoryCurrentPhase? CurrentPhase { get; set; }

    /// <summary>Resource ceilings declared by the factory.</summary>
    [JsonPropertyName("declaredLimits")]
    public FactoryDeclaredLimits DeclaredLimits { get => field ??= new(); set; }

    /// <summary>Number of phases declared by the factory.</summary>
    [JsonPropertyName("declaredPhaseCount")]
    public long DeclaredPhaseCount { get; set; }

    /// <summary>Human-readable factory description.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Registered factory name.</summary>
    [JsonPropertyName("factoryName")]
    public string FactoryName { get; set; } = string.Empty;

    /// <summary>Number of direct factory agents currently live.</summary>
    [JsonPropertyName("liveAgentCount")]
    public long LiveAgentCount { get; set; }

    /// <summary>Epoch milliseconds when this live-overlay snapshot was observed.</summary>
    [JsonPropertyName("observedAt")]
    public long ObservedAt { get; set; }

    /// <summary>Lifecycle and timing observations for each factory phase.</summary>
    [JsonPropertyName("phases")]
    public IList<FactoryPhaseObservation> Phases { get => field ??= []; set; }

    /// <summary>Bidirectional page of durable factory progress.</summary>
    [JsonPropertyName("progress")]
    public FactoryProgressPage Progress { get => field ??= new(); set; }

    /// <summary>Monotonic durable run revision.</summary>
    [JsonPropertyName("revision")]
    public long Revision { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Epoch milliseconds when execution first started, or null before start.</summary>
    [JsonPropertyName("startedAt")]
    public long? StartedAt { get; set; }

    /// <summary>Current factory run status.</summary>
    [JsonPropertyName("status")]
    public FactoryRunStatus Status { get; set; }

    /// <summary>Terminal run outcome, or null while nonterminal.</summary>
    [JsonPropertyName("terminal")]
    public FactoryRunTerminal? Terminal { get; set; }

    /// <summary>Total direct factory agents spawned across all attempts.</summary>
    [JsonPropertyName("totalSpawnedAgentCount")]
    public long TotalSpawnedAgentCount { get; set; }

    /// <summary>Epoch milliseconds when the durable run was last updated.</summary>
    [JsonPropertyName("updatedAt")]
    public long UpdatedAt { get; set; }
}

/// <summary>Parameters for paging factory progress.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryGetRunProgressRequest
{
    /// <summary>Exclusive forward cursor.</summary>
    [JsonPropertyName("afterSeq")]
    public long? AfterSeq { get; set; }

    /// <summary>Exclusive backward cursor.</summary>
    [JsonPropertyName("beforeSeq")]
    public long? BeforeSeq { get; set; }

    /// <summary>Maximum records to return. Defaults to 200 and is capped at 500.</summary>
    [JsonPropertyName("limit")]
    public int? Limit { get; set; }

    /// <summary>Optional phase identifier used to scope records and cursors.</summary>
    [JsonPropertyName("phaseId")]
    public string? PhaseId { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Parameters for cancelling a factory run.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryCancelRequest
{
    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Parameters for pausing a running factory.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryPauseRequest
{
    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>RPC data type for SessionFactoryPauseAtCheckpoint operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionFactoryPauseAtCheckpointResult
{
    /// <summary>Whether this execution attempt must pause or may continue.</summary>
    [JsonPropertyName("action")]
    public FactoryPauseCheckpointAction Action { get; set; }
}

/// <summary>Parameters for an owned durable pause checkpoint.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryPauseCheckpointRequest
{
    /// <summary>Opaque token identifying the execution attempt that reached the checkpoint.</summary>
    [JsonPropertyName("executionToken")]
    public string ExecutionToken { get; set; } = string.Empty;

    /// <summary>Stable author-defined checkpoint key.</summary>
    [JsonPropertyName("key")]
    public string Key { get; set; } = string.Empty;

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Acknowledgement that a factory request was accepted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryAckResult
{
}

/// <summary>One ordered factory progress line.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryLogLine
{
    /// <summary>Progress line kind.</summary>
    [JsonPropertyName("kind")]
    public FactoryLogLineKind Kind { get; set; }

    /// <summary>Monotonic sequence number within the factory run.</summary>
    [JsonPropertyName("seq")]
    public long Seq { get; set; }

    /// <summary>Progress text.</summary>
    [JsonPropertyName("text")]
    public string Text { get; set; } = string.Empty;
}

/// <summary>Parameters for recording factory progress.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryLogRequest
{
    /// <summary>Opaque token identifying the current factory execution attempt.</summary>
    [JsonPropertyName("executionToken")]
    public string ExecutionToken { get; set; } = string.Empty;

    /// <summary>Ordered progress lines to append.</summary>
    [JsonPropertyName("lines")]
    public IList<FactoryLogLine> Lines { get => field ??= []; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of one factory-scoped subagent call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryAgentResult
{
    /// <summary>Agent result, omitted when the agent produced no result.</summary>
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }
}

/// <summary>Options for one factory-scoped subagent call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryAgentOptions
{
    /// <summary>Optional built-in or custom agent name whose definition configures the subagent.</summary>
    [JsonPropertyName("agent")]
    public string? Agent { get; set; }

    /// <summary>Optional context tier override for the subagent.</summary>
    [JsonPropertyName("contextTier")]
    public ContextTier? ContextTier { get; set; }

    /// <summary>Optional label distinguishing otherwise identical memoized agent calls.</summary>
    [JsonPropertyName("label")]
    public string? Label { get; set; }

    /// <summary>Optional model identifier for the subagent.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Optional reasoning effort override for the subagent.</summary>
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Optional JSON Schema for structured agent output.</summary>
    [JsonPropertyName("schema")]
    public JsonElement? Schema { get; set; }
}

/// <summary>Parameters for one factory-scoped subagent call.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryAgentRequest
{
    /// <summary>Opaque token identifying the current factory execution attempt.</summary>
    [JsonPropertyName("executionToken")]
    public string ExecutionToken { get; set; } = string.Empty;

    /// <summary>Factory run identifier that owns the subagent.</summary>
    [JsonPropertyName("factoryRunId")]
    public string FactoryRunId { get; set; } = string.Empty;

    /// <summary>Subagent execution options.</summary>
    [JsonPropertyName("opts")]
    public FactoryAgentOptions Opts { get => field ??= new(); set; }

    /// <summary>Prompt to send to the subagent.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of reading a factory journal entry.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryJournalGetResult
{
    /// <summary>Whether the journal contained the requested key.</summary>
    [JsonPropertyName("hit")]
    public bool Hit { get; set; }

    /// <summary>Cached JSON result. The hit field distinguishes a cached JSON null from a miss.</summary>
    [JsonPropertyName("resultJson")]
    public JsonElement? ResultJson { get; set; }
}

/// <summary>Parameters for reading a factory journal entry.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryJournalGetRequest
{
    /// <summary>Opaque token identifying the current factory execution attempt.</summary>
    [JsonPropertyName("executionToken")]
    public string ExecutionToken { get; set; } = string.Empty;

    /// <summary>Namespaced journal key.</summary>
    [JsonPropertyName("key")]
    public string Key { get; set; } = string.Empty;

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Parameters for storing a factory journal entry.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FactoryJournalPutRequest
{
    /// <summary>Opaque token identifying the current factory execution attempt.</summary>
    [JsonPropertyName("executionToken")]
    public string ExecutionToken { get; set; } = string.Empty;

    /// <summary>Namespaced journal key.</summary>
    [JsonPropertyName("key")]
    public string Key { get; set; } = string.Empty;

    /// <summary>JSON result to memoize.</summary>
    [JsonPropertyName("resultJson")]
    public JsonElement ResultJson { get; set; }

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The session's authoritative model snapshot. Auto preference fields are configuration for the virtual `auto` model and do not change the selected model identifier. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CurrentModel
{
    /// <summary>Auto preference currently claimed by an in-progress activation. Null means the activation is returning to provider-default routing.</summary>
    [JsonPropertyName("activatingAutoTier")]
    public AutoTier? ActivatingAutoTier { get; set; }

    /// <summary>Auto preference currently committed for the session. This can remain available while another model is selected so a later switch to `auto` can reuse it.</summary>
    [JsonPropertyName("autoTier")]
    public AutoTier? AutoTier { get; set; }

    /// <summary>Context tier for models that support multiple context-window sizes.</summary>
    [JsonPropertyName("contextTier")]
    public ContextTier? ContextTier { get; set; }

    /// <summary>Currently active model identifier.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }

    /// <summary>Latest unclaimed Auto preference waiting for a future user turn. Null means the pending request is returning to provider-default routing.</summary>
    [JsonPropertyName("pendingAutoTier")]
    public AutoTier? PendingAutoTier { get; set; }

    /// <summary>Reasoning effort level currently applied to the active model, when one is set. Reads `Session.getReasoningEffort()` synchronously after `getSelectedModel()` resolves so the two values are reported as a snapshot.</summary>
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionModelGetCurrentRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>RPC data type for ModelSwitchConfirmation operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelSwitchConfirmation
{
    /// <summary>Current conversation token count before switching models.</summary>
    [JsonPropertyName("currentTokens")]
    public double CurrentTokens { get; set; }

    /// <summary>Target model token limit used by the compaction preflight.</summary>
    [JsonPropertyName("targetLimit")]
    public double TargetLimit { get; set; }

    /// <summary>Display name of the model that requires compaction confirmation.</summary>
    [JsonPropertyName("targetModelDisplayName")]
    public string TargetModelDisplayName { get; set; } = string.Empty;
}

/// <summary>The model identifier active on the session after the switch.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelSwitchToResult
{
    /// <summary>Compaction confirmation projection when status is confirmation_required.</summary>
    [JsonPropertyName("confirmation")]
    public ModelSwitchConfirmation? Confirmation { get; set; }

    /// <summary>True when the switch was deferred (enqueued as a cancellable `/model` command) because a turn was active or another model change was already queued, rather than applied immediately. When true, the session's live model is unchanged until the queued change drains.</summary>
    [JsonPropertyName("deferred")]
    public bool? Deferred { get; set; }

    /// <summary>Deprecation warnings associated with the selected model or options.</summary>
    [JsonPropertyName("deprecationWarnings")]
    public IList<string>? DeprecationWarnings { get; set; }

    /// <summary>User-facing outcome message for the model switch.</summary>
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Currently active model identifier after the switch.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }

    /// <summary>Authoritative model and Auto preference state after an immediate switch. For deferred switches this remains the current state until the queued change drains.</summary>
    [JsonPropertyName("modelState")]
    public CurrentModel? ModelState { get; set; }

    /// <summary>Persistence failure encountered after applying the model switch.</summary>
    [JsonPropertyName("persistenceError")]
    public string? PersistenceError { get; set; }

    /// <summary>Lifecycle result for the requested switch.</summary>
    [JsonPropertyName("status")]
    public string? Status { get; set; }

    /// <summary>User-facing warning produced while applying the model switch.</summary>
    [JsonPropertyName("warning")]
    public string? Warning { get; set; }
}

/// <summary>Vision-specific limits.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilitiesOverrideLimitsVision
{
    /// <summary>Maximum image size in bytes.</summary>
    [JsonPropertyName("max_prompt_image_size")]
    public long? MaxPromptImageSize { get; set; }

    /// <summary>Maximum number of images per prompt.</summary>
    [JsonPropertyName("max_prompt_images")]
    public long? MaxPromptImages { get; set; }

    /// <summary>MIME types the model accepts.</summary>
    [JsonPropertyName("supported_media_types")]
    public IList<string>? SupportedMediaTypes { get; set; }
}

/// <summary>Token limits for prompts, outputs, and context window.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilitiesOverrideLimits
{
    /// <summary>Maximum total context window size in tokens.</summary>
    [JsonPropertyName("max_context_window_tokens")]
    public long? MaxContextWindowTokens { get; set; }

    /// <summary>Maximum number of output/completion tokens.</summary>
    [JsonPropertyName("max_output_tokens")]
    public long? MaxOutputTokens { get; set; }

    /// <summary>Maximum number of prompt/input tokens.</summary>
    [JsonPropertyName("max_prompt_tokens")]
    public long? MaxPromptTokens { get; set; }

    /// <summary>Vision-specific limits.</summary>
    [JsonPropertyName("vision")]
    public ModelCapabilitiesOverrideLimitsVision? Vision { get; set; }
}

/// <summary>Feature flags indicating what the model supports.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilitiesOverrideSupports
{
    /// <summary>Resolved Anthropic adaptive-thinking capability — unsupported / optional / required. 'required' models reject thinking.type='enabled' with HTTP 400 (e.g. opus-4.7/4.8).</summary>
    [JsonPropertyName("adaptive_thinking")]
    public AdaptiveThinkingSupport? AdaptiveThinking { get; set; }

    /// <summary>Whether this model supports reasoning effort configuration.</summary>
    [JsonPropertyName("reasoningEffort")]
    public bool? ReasoningEffort { get; set; }

    /// <summary>Whether this model supports vision/image input.</summary>
    [JsonPropertyName("vision")]
    public bool? Vision { get; set; }
}

/// <summary>Optional capability overrides (vision, tool_calls, reasoning, etc.).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelCapabilitiesOverride
{
    /// <summary>Token limits for prompts, outputs, and context window.</summary>
    [JsonPropertyName("limits")]
    public ModelCapabilitiesOverrideLimits? Limits { get; set; }

    /// <summary>Feature flags indicating what the model supports.</summary>
    [JsonPropertyName("supports")]
    public ModelCapabilitiesOverrideSupports? Supports { get; set; }
}

/// <summary>Environment variables consulted while resolving model-picker settings.</summary>
public sealed class ModelPickerSettingsContextEnvironment
{
}

/// <summary>Filesystem and environment context used to resolve model-picker settings.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelPickerSettingsContext
{
    /// <summary>Optional Copilot configuration directory containing persisted settings.</summary>
    [JsonPropertyName("configDir")]
    public string? ConfigDir { get; set; }

    /// <summary>Environment variables consulted while resolving model-picker settings.</summary>
    [JsonPropertyName("environment")]
    public ModelPickerSettingsContextEnvironment Environment { get => field ??= new(); set; }

    /// <summary>User home directory used when resolving persisted settings.</summary>
    [JsonPropertyName("homeDirectory")]
    public string HomeDirectory { get; set; } = string.Empty;
}

/// <summary>RPC data type for ModelPickerPersistence operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelPickerPersistenceRequest
{
    /// <summary>Whether context tier was explicitly selected and should be persisted.</summary>
    [JsonPropertyName("contextTierExplicit")]
    public bool? ContextTierExplicit { get; set; }

    /// <summary>Whether reasoning effort was explicitly selected and should be persisted.</summary>
    [JsonPropertyName("reasoningEffortExplicit")]
    public bool? ReasoningEffortExplicit { get; set; }

    /// <summary>Filesystem and environment context used to resolve settings persistence.</summary>
    [JsonPropertyName("settingsContext")]
    public ModelPickerSettingsContext SettingsContext { get => field ??= new(); set; }
}

/// <summary>Target model identifier and optional reasoning effort, summary, capability overrides, and context tier.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ModelSwitchToRequest
{
    /// <summary>Optional Auto routing preference to stage atomically with selecting `auto`. Pass null to return to provider-default Auto routing. This field is rejected when `modelId` is not `auto`.</summary>
    [JsonPropertyName("autoTier")]
    public AutoTier? AutoTier { get; set; }

    /// <summary>Explicit response to a model-switch compaction preflight. Omit to request a confirmation projection when compaction is necessary.</summary>
    [JsonPropertyName("compactionDecision")]
    public string? CompactionDecision { get; set; }

    /// <summary>Explicit context tier for the selected model. `"default"` / `"long_context"` apply the requested tier; omit this field to use normal model behavior with no explicit tier.</summary>
    [JsonPropertyName("contextTier")]
    public ContextTier? ContextTier { get; set; }

    /// <summary>When true, defer this switch (enqueue it) if another model change is already queued, even when no turn is active — so it drains last (FIFO) and wins over the already-queued change. Intended for genuine user-initiated model selections; internal restore/reapply switches omit it and apply immediately when no turn is active. When no other model change is queued this has no effect (a switch still applies immediately unless a turn is active).</summary>
    [JsonPropertyName("deferIfModelChangeQueued")]
    public bool? DeferIfModelChangeQueued { get; set; }

    /// <summary>Override individual model capabilities resolved by the runtime.</summary>
    [JsonPropertyName("modelCapabilities")]
    public ModelCapabilitiesOverride? ModelCapabilities { get; set; }

    /// <summary>Settings scope used when persisting the selected model.</summary>
    [JsonPropertyName("modelChangeScope")]
    public string? ModelChangeScope { get; set; }

    /// <summary>Model selection id to switch to, as returned by `list`. A bare id (e.g. `claude-sonnet-4.6`) names a Copilot (CAPI) model; a provider-qualified id (`provider/id`, e.g. `acme/claude-sonnet`) targets a registry BYOK model.</summary>
    [JsonPropertyName("modelId")]
    public string ModelId { get; set; } = string.Empty;

    /// <summary>Optional settings context and explicit-override flags used to persist a picker selection.</summary>
    [JsonPropertyName("pickerPersistence")]
    public ModelPickerPersistenceRequest? PickerPersistence { get; set; }

    /// <summary>Reasoning effort level to use for the model. CAPI values are model-defined and validated against the selected model; BYOK providers may define additional values. "none" disables reasoning. When omitted, no effort override is applied.</summary>
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Reasoning summary mode to request for supported model clients.</summary>
    [JsonPropertyName("reasoningSummary")]
    public ReasoningSummary? ReasoningSummary { get; set; }

    /// <summary>Optional repository settings scope to persist after the switch commits.</summary>
    [JsonPropertyName("repoScope")]
    public string? RepoScope { get; set; }

    /// <summary>Require the target to be currently available and enabled before applying the switch.</summary>
    [JsonPropertyName("requireAvailable")]
    public bool? RequireAvailable { get; set; }

    /// <summary>When true, evaluate context-window compaction policy before applying the switch.</summary>
    [JsonPropertyName("runCompactionPreflight")]
    public bool? RunCompactionPreflight { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Origin to record on the effective `session.model_change` event for trusted in-process calls. Transport SDK calls are always recorded as `sdk`, regardless of this value.</summary>
    [JsonPropertyName("source")]
    public ModelChangeSource? Source { get; set; }

    /// <summary>Output verbosity level to request for supported models.</summary>
    [JsonPropertyName("verbosity")]
    public Verbosity? Verbosity { get; set; }
}

/// <summary>Immediate acknowledgement and Auto preference snapshot after a switch request. This result never implies that a pending preference committed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelSwitchAutoTierResult
{
    /// <summary>Auto preference currently claimed by an in-progress activation. Null means the activation is returning to provider-default routing.</summary>
    [JsonPropertyName("activatingAutoTier")]
    public AutoTier? ActivatingAutoTier { get; set; }

    /// <summary>Auto preference currently committed for the session.</summary>
    [JsonPropertyName("effectiveAutoTier")]
    public AutoTier? EffectiveAutoTier { get; set; }

    /// <summary>Latest unclaimed Auto preference waiting for a future user turn.</summary>
    [JsonPropertyName("pendingAutoTier")]
    public AutoTier? PendingAutoTier { get; set; }

    /// <summary>Immediate request status. `pending` means accepted but not committed.</summary>
    [JsonPropertyName("status")]
    public ModelSwitchAutoTierStatus Status { get; set; }

    /// <summary>Earlier unclaimed preference replaced by this request. This can be present with either status, including when selecting the effective preference cancels pending work.</summary>
    [JsonPropertyName("supersededAutoTier")]
    public AutoTier? SupersededAutoTier { get; set; }
}

/// <summary>An Auto preference request for the session. This updates Auto configuration only; it does not change the selected model to `auto`.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ModelSwitchAutoTierRequest
{
    /// <summary>Auto preference to activate when a future user turn using the `auto` model safely mints a replacement model and token pair. Pass null to return to provider-default Auto routing.</summary>
    [JsonPropertyName("autoTier")]
    [JsonIgnore(Condition = JsonIgnoreCondition.Never)]
    public AutoTier? AutoTier { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Origin to record on the effective `session.model_change` event. Defaults to `sdk` when omitted.</summary>
    [JsonPropertyName("source")]
    public ModelChangeSource? Source { get; set; }
}

/// <summary>Managed, repository, and CLI model overrides to overlay onto the session at startup.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ModelApplyStartupOverlayRequest
{
    /// <summary>Model explicitly selected by the CLI, when provided.</summary>
    [JsonPropertyName("cliModel")]
    public string? CliModel { get; set; }

    /// <summary>Whether the overlay is being applied while resuming a deferred session.</summary>
    [JsonPropertyName("deferredResume")]
    public bool? DeferredResume { get; set; }

    /// <summary>Model required by device-managed policy, when configured.</summary>
    [JsonPropertyName("deviceManagedModel")]
    public string? DeviceManagedModel { get; set; }

    /// <summary>Startup default model from the enterprise policy helper, when configured. Weakest of the managed sources: it applies only when neither device nor server policy names a model, and an explicit user selection still wins.</summary>
    [JsonPropertyName("policyHelperModel")]
    public string? PolicyHelperModel { get; set; }

    /// <summary>Context tier selected by repository settings, when configured.</summary>
    [JsonPropertyName("repoContextTier")]
    public string? RepoContextTier { get; set; }

    /// <summary>Model selected by repository settings, when configured.</summary>
    [JsonPropertyName("repoModel")]
    public string? RepoModel { get; set; }

    /// <summary>Reasoning effort selected by repository settings, when configured.</summary>
    [JsonPropertyName("repoReasoningEffort")]
    public string? RepoReasoningEffort { get; set; }

    /// <summary>Model required by server-managed policy, when configured.</summary>
    [JsonPropertyName("serverManagedModel")]
    public string? ServerManagedModel { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The applied host allowlist and effective session model policy after intersection.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelSetAllowedModelsResult
{
    /// <summary>Normalized host allowlist. Omitted when the host restriction was cleared, or when a relay client does not return the host policy.</summary>
    [JsonPropertyName("allowedModels")]
    public IList<string>? AllowedModels { get; set; }

    /// <summary>Effective exact IDs or repository policy patterns after applying the host restriction. Omitted by relay clients that do not return the host policy.</summary>
    [JsonPropertyName("effectiveAllowedModels")]
    public IList<string>? EffectiveAllowedModels { get; set; }

    /// <summary>Effective deterministic fallback model, when the policy defines one.</summary>
    [JsonPropertyName("fallbackModel")]
    public string? FallbackModel { get; set; }

    /// <summary>Selected session model after reconciling a now-disallowed concrete selection.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }
}

/// <summary>Host-supplied exact model selection IDs to allow for this running session. CAPI IDs are intersected with repository `.github/allowed_models.txt` policy; provider-qualified IDs remain exempt from repository-only policy but are restricted by this host list. Omit or pass null to clear the host restriction; an explicit empty or disjoint list is rejected. Validation and pre-selection fallback failures preserve the previous restriction. Failures after a fallback selection commits retain the new restriction and selected model; callers should inspect current session state after such an error.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ModelSetAllowedModelsRequest
{
    /// <summary>Exact model IDs to permit, or null to clear the host restriction.</summary>
    [JsonPropertyName("allowedModels")]
    public IList<string>? AllowedModels { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Update the session's reasoning effort without changing the selected model. Use `switchTo` instead when you also need to change the model. The runtime stores the effort on the session and applies it to subsequent turns.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelSetReasoningEffortResult
{
    /// <summary>Reasoning effort level recorded on the session after the update.</summary>
    [JsonPropertyName("reasoningEffort")]
    public string ReasoningEffort { get; set; } = string.Empty;
}

/// <summary>Reasoning effort level to apply to the currently selected model.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ModelSetReasoningEffortRequest
{
    /// <summary>Reasoning effort level to apply to the currently selected model. The host is responsible for validating the value against the model's supported levels before calling.</summary>
    [JsonPropertyName("reasoningEffort")]
    public string ReasoningEffort { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Cost-category metadata for a CAPI model.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionModelPriceCategory
{
    /// <summary>CAPI model identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Cost category assigned to the model.</summary>
    [JsonPropertyName("priceCategory")]
    public ModelPickerPriceCategory PriceCategory { get; set; }
}

/// <summary>The list of models available to this session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionModelList
{
    /// <summary>Available models, ordered with the most preferred default first. Includes both Copilot (CAPI) models and any registry BYOK models; a BYOK model appears under its provider-qualified selection id (`provider/id`).</summary>
    [JsonPropertyName("list")]
    public IList<JsonElement> List { get => field ??= []; set; }

    /// <summary>Cost categories for the full CAPI catalog, including picker-disabled models that Auto may select. Metadata only; entries absent from `list` are not manually selectable.</summary>
    [JsonPropertyName("modelPriceCategories")]
    public IList<SessionModelPriceCategory>? ModelPriceCategories { get; set; }

    /// <summary>Per-quota snapshots returned alongside the model list, keyed by quota type.</summary>
    [JsonPropertyName("quotaSnapshots")]
    public IDictionary<string, JsonElement>? QuotaSnapshots { get; set; }
}

/// <summary>RPC data type for SessionModelList operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionModelListRequest
{
    /// <summary>If true, bypasses the per-session model list cache and re-fetches from CAPI.</summary>
    [JsonPropertyName("skipCache")]
    public bool? SkipCache { get; set; }
}

/// <summary>RPC data type for SessionModelListRequestWithSession operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionModelListRequestWithSession
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>If true, bypasses the per-session model list cache and re-fetches from CAPI.</summary>
    [JsonPropertyName("skipCache")]
    public bool? SkipCache { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionModeGetRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Outcome of a session mode change, including any model switch it triggered and follow-up the host must perform.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModeSetResult
{
    /// <summary>Whether the host should arm an interactive continuation after the mode change.</summary>
    [JsonPropertyName("armInteractiveContinuation")]
    public bool? ArmInteractiveContinuation { get; set; }

    /// <summary>Compaction confirmation required before the mode change can complete.</summary>
    [JsonPropertyName("confirmation")]
    public ModelSwitchConfirmation? Confirmation { get; set; }

    /// <summary>Whether the host must defer implementing the requested mode change.</summary>
    [JsonPropertyName("deferImplementation")]
    public bool? DeferImplementation { get; set; }

    /// <summary>Deprecation warnings associated with the model selected by the mode change.</summary>
    [JsonPropertyName("deprecationWarnings")]
    public IList<string>? DeprecationWarnings { get; set; }

    /// <summary>User-facing outcome message for the model switch triggered by the mode change.</summary>
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Whether applying the mode changed the active model.</summary>
    [JsonPropertyName("modelChanged")]
    public bool ModelChanged { get; set; }

    /// <summary>Lifecycle status of the requested mode change.</summary>
    [JsonPropertyName("status")]
    public string Status { get; set; } = string.Empty;

    /// <summary>User-facing warning produced while applying the mode change.</summary>
    [JsonPropertyName("warning")]
    public string? Warning { get; set; }
}

/// <summary>Agent interaction mode to apply to the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ModeSetRequest
{
    /// <summary>Explicit response to a model-switch compaction preflight.</summary>
    [JsonPropertyName("compactionDecision")]
    public string? CompactionDecision { get; set; }

    /// <summary>Session whose plan-mode base state should be inherited.</summary>
    [JsonPropertyName("inheritPlanBaseFromSessionId")]
    public string? InheritPlanBaseFromSessionId { get; set; }

    /// <summary>The session mode the agent is operating in.</summary>
    [JsonPropertyName("mode")]
    public SessionMode Mode { get; set; }

    /// <summary>Whether the selected plan model should be persisted.</summary>
    [JsonPropertyName("persistPlanSelection")]
    public bool? PersistPlanSelection { get; set; }

    /// <summary>Settings context used when persisting the selected plan model.</summary>
    [JsonPropertyName("pickerSettingsContext")]
    public ModelPickerSettingsContext? PickerSettingsContext { get; set; }

    /// <summary>Context tier to use with the dedicated plan model.</summary>
    [JsonPropertyName("planContextTier")]
    public string? PlanContextTier { get; set; }

    /// <summary>Action to perform when leaving plan mode.</summary>
    [JsonPropertyName("planExitAction")]
    public string? PlanExitAction { get; set; }

    /// <summary>Dedicated model to use in plan mode, when configured.</summary>
    [JsonPropertyName("planModel")]
    public string? PlanModel { get; set; }

    /// <summary>Whether a dedicated plan model is configured.</summary>
    [JsonPropertyName("planModelConfigured")]
    public bool? PlanModelConfigured { get; set; }

    /// <summary>Reasoning effort to use with the dedicated plan model.</summary>
    [JsonPropertyName("planReasoningEffort")]
    public string? PlanReasoningEffort { get; set; }

    /// <summary>Whether leaving plan mode should restore the session's previous model.</summary>
    [JsonPropertyName("restorePlanModel")]
    public bool? RestorePlanModel { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The session's friendly name, or null when not yet set.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class NameGetResult
{
    /// <summary>The session name (user-set or auto-generated), or null if not yet set.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionNameGetRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>New friendly name to apply to the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class NameSetRequest
{
    /// <summary>New session name (1–100 characters, trimmed of leading/trailing whitespace).</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [MaxLength(100)]
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the auto-generated summary was applied as the session's name.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class NameSetAutoResult
{
    /// <summary>Whether the auto-generated summary was persisted. False if the session already has a user-set name, the summary normalized to empty, or the session does not have a workspace.</summary>
    [JsonPropertyName("applied")]
    public bool Applied { get; set; }
}

/// <summary>Auto-generated session summary to apply as the session's name when no user-set name exists.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class NameSetAutoRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Auto-generated session summary. Empty/whitespace-only values are ignored; values are trimmed before persisting.</summary>
    [JsonPropertyName("summary")]
    public string Summary { get; set; } = string.Empty;
}

/// <summary>Existence, contents, and resolved path of the session plan file.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PlanReadResult
{
    /// <summary>The content of the plan file, or null if it does not exist.</summary>
    [JsonPropertyName("content")]
    public string? Content { get; set; }

    /// <summary>Whether the plan file exists in the workspace.</summary>
    [JsonPropertyName("exists")]
    public bool Exists { get; set; }

    /// <summary>Absolute file path of the plan file, or null if workspace is not enabled.</summary>
    [JsonPropertyName("path")]
    public string? Path { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionPlanReadRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Replacement contents to write to the session plan file.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PlanUpdateRequest
{
    /// <summary>The new content for the plan file.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionPlanDeleteRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A single todo row read from the session SQL `todos` table. All fields are optional because the SQL schema is best-effort and the agent may not have populated every column.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PlanSqlTodosRow
{
    /// <summary>Todo creation time, as stored by the session SQL schema's `datetime('now')` default: `YYYY-MM-DD HH:MM:SS` in UTC. Lets clients attribute todos to the work item that created them (e.g. scoping a goal's progress to the todos it produced) rather than to the whole session.</summary>
    [JsonPropertyName("createdAt")]
    public string? CreatedAt { get; set; }

    /// <summary>Todo description.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Todo identifier.</summary>
    [JsonPropertyName("id")]
    public string? Id { get; set; }

    /// <summary>Todo status.</summary>
    [JsonPropertyName("status")]
    public string? Status { get; set; }

    /// <summary>Todo title.</summary>
    [JsonPropertyName("title")]
    public string? Title { get; set; }
}

/// <summary>Todo rows read from the session SQL database. Empty when no session database is available.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PlanReadSqlTodosResult
{
    /// <summary>Rows from the session SQL todos table, ordered by creation time with insertion order used to break ties when available and id used for WITHOUT ROWID tables.</summary>
    [JsonPropertyName("rows")]
    public IList<PlanSqlTodosRow> Rows { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionPlanReadSqlTodosRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A single dependency edge read from the session SQL `todo_deps` table, indicating that one todo must complete before another.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PlanSqlTodoDependency
{
    /// <summary>ID of the todo it depends on.</summary>
    [JsonPropertyName("dependsOn")]
    public string DependsOn { get; set; } = string.Empty;

    /// <summary>ID of the todo that has the dependency.</summary>
    [JsonPropertyName("todoId")]
    public string TodoId { get; set; } = string.Empty;
}

/// <summary>Todo rows + dependency edges read from the session SQL database.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PlanReadSqlTodosWithDependenciesResult
{
    /// <summary>Edges from the session SQL todo_deps table. Empty when no database, no todo_deps table, or the SELECT failed. Read independently from `rows`, so a broken todo_deps table does not affect the rows result and vice versa.</summary>
    [JsonPropertyName("dependencies")]
    public IList<PlanSqlTodoDependency> Dependencies { get => field ??= []; set; }

    /// <summary>Rows from the session SQL todos table, ordered by creation time with insertion order used to break ties when available and id used for WITHOUT ROWID tables. Empty when no database, no todos table, or the SELECT failed.</summary>
    [JsonPropertyName("rows")]
    public IList<PlanSqlTodosRow> Rows { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionPlanReadSqlTodosWithDependenciesRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>RPC data type for WorkspacesGetWorkspaceResultWorkspace operations.</summary>
public sealed class WorkspacesGetWorkspaceResultWorkspace
{
    /// <summary>Current Git branch.</summary>
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Whether the per-session Chronicle upgrade prompt was dismissed for the workspace.</summary>
    [JsonPropertyName("chronicle_sync_dismissed")]
    public bool? ChronicleSyncDismissed { get; set; }

    /// <summary>Name of the client that created the workspace.</summary>
    [JsonPropertyName("client_name")]
    public string? ClientName { get; set; }

    /// <summary>Timestamp when the workspace was created.</summary>
    [JsonPropertyName("created_at")]
    public DateTimeOffset? CreatedAt { get; set; }

    /// <summary>Current working directory associated with the workspace.</summary>
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Git repository root associated with the workspace.</summary>
    [JsonPropertyName("git_root")]
    public string? GitRoot { get; set; }

    /// <summary>Allowed values for the `WorkspacesWorkspaceDetailsHostType` enumeration.</summary>
    [JsonPropertyName("host_type")]
    public WorkspacesWorkspaceDetailsHostType? HostType { get; set; }

    /// <summary>Stable workspace identifier.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Most recent Mission Control event identifier observed for the workspace.</summary>
    [JsonPropertyName("mc_last_event_id")]
    public string? McLastEventId { get; set; }

    /// <summary>Mission Control session identifier associated with the workspace.</summary>
    [JsonPropertyName("mc_session_id")]
    public string? McSessionId { get; set; }

    /// <summary>Mission Control task identifier associated with the workspace.</summary>
    [JsonPropertyName("mc_task_id")]
    public string? McTaskId { get; set; }

    /// <summary>Workspace display name.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Whether the workspace session can be steered remotely.</summary>
    [JsonPropertyName("remote_steerable")]
    public bool? RemoteSteerable { get; set; }

    /// <summary>Repository identifier associated with the workspace.</summary>
    [JsonPropertyName("repository")]
    public string? Repository { get; set; }

    /// <summary>Number of persisted summaries in the workspace.</summary>
    [JsonPropertyName("summary_count")]
    public long? SummaryCount { get; set; }

    /// <summary>Timestamp when the workspace was last updated.</summary>
    [JsonPropertyName("updated_at")]
    public DateTimeOffset? UpdatedAt { get; set; }

    /// <summary>Whether the workspace name was explicitly chosen by the user.</summary>
    [JsonPropertyName("user_named")]
    public bool? UserNamed { get; set; }
}

/// <summary>Current workspace metadata for the session, including its absolute filesystem path when available.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesGetWorkspaceResult
{
    /// <summary>Absolute filesystem path to the workspace directory. Omitted when the session has no workspace (e.g. remote sessions).</summary>
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>Current workspace metadata, or null if not available.</summary>
    [JsonPropertyName("workspace")]
    public WorkspacesGetWorkspaceResultWorkspace? Workspace { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionWorkspacesGetWorkspaceRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Workspace metadata fields to update.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesUpdateMetadataRequest
{
    /// <summary>Opaque workspace context supplied by the session host.</summary>
    [JsonPropertyName("context")]
    public JsonElement? Context { get; set; }

    /// <summary>Optional workspace display name override.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Optional session context used when creating a local workspace.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesEnsureRequest
{
    /// <summary>Opaque workspace context supplied by the session host.</summary>
    [JsonPropertyName("context")]
    public JsonElement? Context { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Relative paths of files stored in the session workspace files directory.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesListFilesResult
{
    /// <summary>Relative file paths in the workspace files directory.</summary>
    [JsonPropertyName("files")]
    public IList<string> Files { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionWorkspacesListFilesRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Contents of the requested workspace file as a UTF-8 string.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesReadFileResult
{
    /// <summary>File content as a UTF-8 string.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;
}

/// <summary>Relative path of the workspace file to read.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesReadFileRequest
{
    /// <summary>Relative path within the workspace files directory.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Relative path and UTF-8 content for the workspace file to create or overwrite.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesCreateFileRequest
{
    /// <summary>File content to write as a UTF-8 string.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Relative path within the workspace files directory.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Workspace checkpoint metadata with assigned number, human-readable title, and checkpoint filename.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesCheckpoints
{
    /// <summary>Filename of the checkpoint within the workspace checkpoints directory.</summary>
    [JsonPropertyName("filename")]
    public string Filename { get; set; } = string.Empty;

    /// <summary>Checkpoint number assigned by the workspace manager.</summary>
    [JsonPropertyName("number")]
    public long Number { get; set; }

    /// <summary>Human-readable checkpoint title.</summary>
    [JsonPropertyName("title")]
    public string Title { get; set; } = string.Empty;
}

/// <summary>Workspace checkpoints in chronological order; empty when the workspace is not enabled.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesListCheckpointsResult
{
    /// <summary>Workspace checkpoints in chronological order. Empty when workspace is not enabled.</summary>
    [JsonPropertyName("checkpoints")]
    public IList<WorkspacesCheckpoints> Checkpoints { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionWorkspacesListCheckpointsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Checkpoint content as a UTF-8 string, or null when the checkpoint or workspace is missing.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesReadCheckpointResult
{
    /// <summary>Checkpoint content as a UTF-8 string, or null when the checkpoint or workspace is missing.</summary>
    [JsonPropertyName("content")]
    public string? Content { get; set; }
}

/// <summary>Checkpoint number to read.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesReadCheckpointRequest
{
    /// <summary>Checkpoint number to read.</summary>
    [JsonPropertyName("number")]
    public long Number { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Metadata for the persisted summary.</summary>
public sealed class WorkspacesAddSummaryResultSummary
{
}

/// <summary>Refreshed metadata for the containing workspace.</summary>
public sealed class WorkspacesAddSummaryResultWorkspace
{
}

/// <summary>Persisted summary metadata and refreshed workspace metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesAddSummaryResult
{
    /// <summary>Metadata for the persisted summary.</summary>
    [JsonPropertyName("summary")]
    public WorkspacesAddSummaryResultSummary? Summary { get; set; }

    /// <summary>Refreshed metadata for the containing workspace.</summary>
    [JsonPropertyName("workspace")]
    public WorkspacesAddSummaryResultWorkspace? Workspace { get; set; }
}

/// <summary>Compaction summary checkpoint to persist.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesAddSummaryRequest
{
    /// <summary>Markdown summary content to persist.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Summary title shown in checkpoint listings.</summary>
    [JsonPropertyName("title")]
    public string Title { get; set; } = string.Empty;
}

/// <summary>Rollback point for local workspace summaries.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesTruncateSummariesRequest
{
    /// <summary>Number of newest summaries to keep.</summary>
    [JsonPropertyName("keepCount")]
    public long KeepCount { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Autopilot objective file content, or null when missing.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesReadAutopilotObjectiveResult
{
    /// <summary>Autopilot objective file content, or null when missing.</summary>
    [JsonPropertyName("content")]
    public string? Content { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionWorkspacesReadAutopilotObjectiveRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of writing the autopilot objective file.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesWriteAutopilotObjectiveResult
{
    /// <summary>Filesystem operation performed.</summary>
    [JsonPropertyName("operation")]
    public string Operation { get; set; } = string.Empty;
}

/// <summary>Autopilot objective file content to persist.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesWriteAutopilotObjectiveRequest
{
    /// <summary>Autopilot objective file content.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of deleting the autopilot objective file.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesDeleteAutopilotObjectiveResult
{
    /// <summary>True when a file was deleted.</summary>
    [JsonPropertyName("deleted")]
    public bool Deleted { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionWorkspacesDeleteAutopilotObjectiveRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Whether the autopilot objective file exists.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesAutopilotObjectiveExistsResult
{
    /// <summary>True when the objective file exists.</summary>
    [JsonPropertyName("exists")]
    public bool Exists { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionWorkspacesAutopilotObjectiveExistsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>RPC data type for WorkspacesSaveLargePasteResultSaved operations.</summary>
public sealed class WorkspacesSaveLargePasteResultSaved
{
    /// <summary>Filename within the workspace files directory.</summary>
    [JsonPropertyName("filename")]
    public string Filename { get; set; } = string.Empty;

    /// <summary>Absolute filesystem path to the saved paste file.</summary>
    [JsonPropertyName("filePath")]
    public string FilePath { get; set; } = string.Empty;

    /// <summary>Size of the saved file in bytes.</summary>
    [JsonPropertyName("sizeBytes")]
    public long SizeBytes { get; set; }
}

/// <summary>Descriptor for the saved paste file, or null when the workspace is unavailable.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesSaveLargePasteResult
{
    /// <summary>Saved-paste descriptor, or null when the workspace is unavailable (e.g. CCA runtime, non-infinite sessions, remote sessions).</summary>
    [JsonPropertyName("saved")]
    public WorkspacesSaveLargePasteResultSaved? Saved { get; set; }
}

/// <summary>Pasted content to save as a UTF-8 file in the session workspace.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesSaveLargePasteRequest
{
    /// <summary>Pasted content to save as a UTF-8 file.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A single changed file and its unified diff.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspaceDiffFileChange
{
    /// <summary>Type of change represented by this file diff.</summary>
    [JsonPropertyName("changeType")]
    public WorkspaceDiffFileChangeType ChangeType { get; set; }

    /// <summary>Unified diff content for the file. Empty when the diff was truncated.</summary>
    [JsonPropertyName("diff")]
    public string Diff { get; set; } = string.Empty;

    /// <summary>Whether the diff content was omitted because it exceeded the per-file size limit.</summary>
    [JsonPropertyName("isTruncated")]
    public bool? IsTruncated { get; set; }

    /// <summary>Original file path for renamed files.</summary>
    [JsonPropertyName("oldPath")]
    public string? OldPath { get; set; }

    /// <summary>Path to the changed file, relative to the workspace root when the file lives under it. A file changed outside the workspace root keeps a `../`-relative path, or an absolute path when no relative path exists (for example a different Windows drive).</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;
}

/// <summary>Workspace diff result for the requested mode.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspaceDiffResult
{
    /// <summary>Default branch used for a branch diff, when branch mode was requested.</summary>
    [JsonPropertyName("baseBranch")]
    public string? BaseBranch { get; set; }

    /// <summary>Changed files and their unified diffs.</summary>
    [JsonPropertyName("changes")]
    public IList<WorkspaceDiffFileChange> Changes { get => field ??= []; set; }

    /// <summary>Whether the requested diff fell back to unstaged changes, either because branch diff failed or session diff was unavailable.</summary>
    [JsonPropertyName("isFallback")]
    public bool IsFallback { get; set; }

    /// <summary>Effective mode used for the returned changes.</summary>
    [JsonPropertyName("mode")]
    public WorkspaceDiffMode Mode { get; set; }

    /// <summary>Diff mode requested by the client.</summary>
    [JsonPropertyName("requestedMode")]
    public WorkspaceDiffMode RequestedMode { get; set; }

    /// <summary>Why the session diff could not be produced, when applicable. Set only when `session` mode was requested and `isFallback` is true, so a client can tell the permanent `file-change-tracking-disabled` apart from the transient `session-busy`, which the same request answers once the session settles. Never set for `unstaged` or `branch` mode, and never `unsupported-remote-session`: a remote session's captures live on its own host, so a `session`-mode diff is rejected for one rather than answered with a controller-side fallback.</summary>
    [JsonPropertyName("unavailableReason")]
    public HistoryRewindUnavailableReason? UnavailableReason { get; set; }
}

/// <summary>Parameters for computing a workspace diff.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class WorkspacesDiffRequest
{
    /// <summary>When true, ignore whitespace-only changes (git `--ignore-all-space`). Defaults to false.</summary>
    [JsonPropertyName("ignoreWhitespace")]
    public bool? IgnoreWhitespace { get; set; }

    /// <summary>Diff mode requested by the client.</summary>
    [JsonPropertyName("mode")]
    public WorkspaceDiffMode Mode { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Current per-window credit limit and consumption for an autopilot objective.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AutopilotObjectiveCreditLimit
{
    /// <summary>Configured AI-credit cap, when one is set.</summary>
    [JsonPropertyName("credits")]
    public double? Credits { get; set; }

    /// <summary>Window consumption in fractional AI credits, for display.</summary>
    [JsonPropertyName("creditsUsed")]
    public double CreditsUsed { get; set; }

    /// <summary>Exact window consumption in non-negative integer nano-AIU, encoded as a decimal string.</summary>
    [RegularExpression("^[0-9]+$")]
    [JsonPropertyName("creditsUsedNanoAiu")]
    public string CreditsUsedNanoAiu { get; set; } = string.Empty;
}

/// <summary>Public, persistence-independent projection of an autopilot objective.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AutopilotObjectiveState
{
    /// <summary>Optional summary recorded when the objective completed.</summary>
    [JsonPropertyName("completionSummary")]
    public string? CompletionSummary { get; set; }

    /// <summary>Exact lifetime AI-credit consumption in non-negative integer nano-AIU, encoded as a decimal string.</summary>
    [RegularExpression("^[0-9]+$")]
    [JsonPropertyName("creditCountNanoAiu")]
    public string CreditCountNanoAiu { get; set; } = string.Empty;

    /// <summary>Current per-window consumption and optional cap, when a credit-tracking window is present.</summary>
    [JsonPropertyName("creditLimit")]
    public AutopilotObjectiveCreditLimit? CreditLimit { get; set; }

    /// <summary>Session-local objective identifier.</summary>
    [JsonPropertyName("id")]
    public long Id { get; set; }

    /// <summary>User-provided objective text.</summary>
    [JsonPropertyName("objective")]
    public string Objective { get; set; } = string.Empty;

    /// <summary>Optional reason the objective is paused.</summary>
    [JsonPropertyName("pauseReason")]
    public string? PauseReason { get; set; }

    /// <summary>Current normalized lifecycle status.</summary>
    [JsonPropertyName("status")]
    public AutopilotObjectiveStatus Status { get; set; }

    /// <summary>Number of objective turns started.</summary>
    [JsonPropertyName("turnCount")]
    public long TurnCount { get; set; }
}

/// <summary>Canonical runtime state for the session's current autopilot objective.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AutopilotObjectiveGetStateResult
{
    /// <summary>Current objective state, or `null` when the session has no objective.</summary>
    [JsonPropertyName("state")]
    public AutopilotObjectiveState? State { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAutopilotObjectiveGetStateRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Characters that, when typed in the composer, should trigger a `completions.request`. Empty when the session has no host-driven completions (e.g. local sessions, or a relay host that does not advertise `completionTriggerCharacters`).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CompletionsGetTriggerCharactersResult
{
    /// <summary>Trigger characters advertised by the host (e.g. `["@", "#"]`). Empty disables host-driven completions for the session.</summary>
    [JsonPropertyName("triggerCharacters")]
    public IList<string> TriggerCharacters { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionCompletionsGetTriggerCharactersRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A single host-driven completion. Accepting an item replaces `[rangeStart, rangeEnd)` (UTF-16 code units) in the composer with `insertText`; when the range is absent, the active token around the cursor is replaced.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionCompletionItem
{
    /// <summary>Text spliced into the composer when the item is accepted.</summary>
    [JsonPropertyName("insertText")]
    public string InsertText { get; set; } = string.Empty;

    /// <summary>Render-kind hint for the picker row (e.g. `"document"`, `"directory"`), derived from the host's display kind.</summary>
    [JsonPropertyName("kind")]
    public string? Kind { get; set; }

    /// <summary>Primary display label for the picker row. Falls back to `insertText` when absent.</summary>
    [JsonPropertyName("label")]
    public string? Label { get; set; }

    /// <summary>End (exclusive) of the replacement range in `text`, in UTF-16 code units.</summary>
    [JsonPropertyName("rangeEnd")]
    public long? RangeEnd { get; set; }

    /// <summary>Start of the replacement range in `text`, in UTF-16 code units.</summary>
    [JsonPropertyName("rangeStart")]
    public long? RangeStart { get; set; }
}

/// <summary>Host-driven completion items for the current composer input. Empty when the host returns no items or does not support completions.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CompletionsRequestResult
{
    /// <summary>Completion items in host-ranked order.</summary>
    [JsonPropertyName("items")]
    public IList<SessionCompletionItem> Items { get => field ??= []; set; }
}

/// <summary>Request host-driven completions for the current composer input.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CompletionsRequestRequest
{
    /// <summary>Cursor offset within `text`, in UTF-16 code units.</summary>
    [JsonPropertyName("offset")]
    public long Offset { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>The full composed composer input.</summary>
    [JsonPropertyName("text")]
    public string Text { get; set; } = string.Empty;
}

/// <summary>Instruction sources loaded for the session, in merge order.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InstructionsGetSourcesResult
{
    /// <summary>Instruction sources for the session.</summary>
    [JsonPropertyName("sources")]
    public IList<InstructionSource> Sources { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionInstructionsGetSourcesRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether fleet mode was successfully activated.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FleetStartResult
{
    /// <summary>Whether fleet mode was successfully activated.</summary>
    [JsonPropertyName("started")]
    public bool Started { get; set; }
}

/// <summary>Optional user prompt to combine with the fleet orchestration instructions.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FleetStartRequest
{
    /// <summary>Optional user prompt to combine with fleet instructions.</summary>
    [JsonPropertyName("prompt")]
    public string? Prompt { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Agents available to the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentList
{
    /// <summary>Available agents.</summary>
    [JsonPropertyName("agents")]
    public IList<AgentInfo> Agents { get => field ??= []; set; }
}

/// <summary>RPC data type for SessionAgentList operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionAgentListRequest
{
    /// <summary>When true, request the session's configured built-in agents alongside custom agents. Listing applies feature, context, inclusion, exclusion, and user-disabled-agent policy, but does not evaluate transient invocation requirements such as model availability. Built-in metadata may be omitted when the session cannot project it, such as a relay session.</summary>
    [JsonPropertyName("includeBuiltInAgents")]
    public bool? IncludeBuiltInAgents { get; set; }

    /// <summary>When true, request authored base prompt text on each AgentInfo. Prompt text may be omitted when unavailable, such as for agents projected through a relay session.</summary>
    [JsonPropertyName("includePrompt")]
    public bool? IncludePrompt { get; set; }
}

/// <summary>RPC data type for SessionAgentListRequestWithSession operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAgentListRequestWithSession
{
    /// <summary>When true, request the session's configured built-in agents alongside custom agents. Listing applies feature, context, inclusion, exclusion, and user-disabled-agent policy, but does not evaluate transient invocation requirements such as model availability. Built-in metadata may be omitted when the session cannot project it, such as a relay session.</summary>
    [JsonPropertyName("includeBuiltInAgents")]
    public bool? IncludeBuiltInAgents { get; set; }

    /// <summary>When true, request authored base prompt text on each AgentInfo. Prompt text may be omitted when unavailable, such as for agents projected through a relay session.</summary>
    [JsonPropertyName("includePrompt")]
    public bool? IncludePrompt { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>An in-memory authored prompt override for an available agent.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AgentSetPromptRequest
{
    /// <summary>Stable effective agent id. Plugin namespace separators are normalized.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Replacement authored prompt. Empty text is valid.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The currently selected custom agent, or null when using the default agent.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentGetCurrentResult
{
    /// <summary>Currently selected custom agent, or null if using the default agent.</summary>
    [JsonPropertyName("agent")]
    public AgentInfo? Agent { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAgentGetCurrentRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The newly selected custom agent.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentSelectResult
{
    /// <summary>The newly selected custom agent.</summary>
    [JsonPropertyName("agent")]
    public AgentInfo Agent { get => field ??= new(); set; }
}

/// <summary>Name of the custom agent to select for subsequent turns.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class AgentSelectRequest
{
    /// <summary>Name of the custom agent to select.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAgentDeselectRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Custom agents available to the session after reloading definitions from disk.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentReloadResult
{
    /// <summary>Reloaded custom agents.</summary>
    [JsonPropertyName("agents")]
    public IList<AgentInfo> Agents { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionAgentReloadRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifier assigned to the newly started background agent task.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksStartAgentResult
{
    /// <summary>Generated agent ID for the background task.</summary>
    [JsonPropertyName("agentId")]
    public string AgentId { get; set; } = string.Empty;
}

/// <summary>Agent type, prompt, name, and optional description and model override for the new task.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksStartAgentRequest
{
    /// <summary>Type of agent to start (e.g., 'explore', 'task', 'general-purpose').</summary>
    [JsonPropertyName("agentType")]
    public string AgentType { get; set; } = string.Empty;

    /// <summary>Short description of the task.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Optional model override.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Friendly, non-unique name used when displaying the agent.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Task prompt for the agent.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Tracked task union returned by task APIs, containing an agent, client, or shell task.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(TaskInfoAgent), "agent")]
[JsonDerivedType(typeof(TaskInfoClient), "client")]
[JsonDerivedType(typeof(TaskInfoShell), "shell")]
public partial class TaskInfo
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>Tracked background agent task metadata, including IDs, status, timing, agent type, prompt, model, result, and latest response.</summary>
/// <remarks>The <c>agent</c> variant of <see cref="TaskInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskInfoAgent : TaskInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "agent";

    /// <summary>ISO 8601 timestamp when the current active period began.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("activeStartedAt")]
    public DateTimeOffset? ActiveStartedAt { get; set; }

    /// <summary>Accumulated active execution time in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("activeTimeMs")]
    public TimeSpan? ActiveTime { get; set; }

    /// <summary>Type of agent running this task.</summary>
    [JsonPropertyName("agentType")]
    public required string AgentType { get; set; }

    /// <summary>Whether the task is currently in the original sync wait and can be moved to background mode. False once it is already backgrounded, idle, finished, or no longer has a promotable sync waiter.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("canPromoteToBackground")]
    public bool? CanPromoteToBackground { get; set; }

    /// <summary>ISO 8601 timestamp when the task finished.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("completedAt")]
    public DateTimeOffset? CompletedAt { get; set; }

    /// <summary>Short description of the task.</summary>
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Friendly, non-unique name intended for display.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>Error message when the task failed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Whether task execution is synchronously awaited or managed in the background.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("executionMode")]
    public TaskExecutionMode? ExecutionMode { get; set; }

    /// <summary>Unique task identifier.</summary>
    [JsonPropertyName("id")]
    public required string Id { get; set; }

    /// <summary>ISO 8601 timestamp when the agent entered idle state.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("idleSince")]
    public DateTimeOffset? IdleSince { get; set; }

    /// <summary>Most recent response text from the agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("latestResponse")]
    public string? LatestResponse { get; set; }

    /// <summary>Requested model override for the task when specified.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Most recent prompt delivered to the agent. Updated whenever the agent receives a follow-up message.</summary>
    [JsonPropertyName("prompt")]
    public required string Prompt { get; set; }

    /// <summary>Runtime model resolved for the task when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("resolvedModel")]
    public string? ResolvedModel { get; set; }

    /// <summary>Result text from the task when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("result")]
    public string? Result { get; set; }

    /// <summary>ISO 8601 timestamp when the task was started.</summary>
    [JsonPropertyName("startedAt")]
    public required DateTimeOffset StartedAt { get; set; }

    /// <summary>Current lifecycle status of the task.</summary>
    [JsonPropertyName("status")]
    public required TaskStatus Status { get; set; }

    /// <summary>Tool call ID associated with this agent task.</summary>
    [JsonPropertyName("toolCallId")]
    public required string ToolCallId { get; set; }
}

/// <summary>Public owner attribution for a client-owned task. Identifiers are opaque and never authorize requests.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TaskClientOwner
{
    /// <summary>ISO 8601 timestamp when the bound join disconnected.</summary>
    [JsonPropertyName("disconnectedAt")]
    public DateTimeOffset? DisconnectedAt { get; set; }

    /// <summary>Display-only owner name.</summary>
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>Opaque identity of the currently or most recently bound session join.</summary>
    [JsonPropertyName("joinId")]
    public string JoinId { get; set; } = string.Empty;

    /// <summary>Class of the task owner.</summary>
    [JsonPropertyName("kind")]
    public TaskClientOwnerKind Kind { get; set; }

    /// <summary>Opaque session-scoped participant identity.</summary>
    [JsonPropertyName("participantId")]
    public string ParticipantId { get; set; } = string.Empty;

    /// <summary>Whether this task's bound join is currently connected.</summary>
    [JsonPropertyName("presence")]
    public TaskClientOwnerPresence Presence { get; set; }

    /// <summary>Display-only owner source.</summary>
    [JsonPropertyName("source")]
    public string? Source { get; set; }
}

/// <summary>Tracked client-owned task metadata.</summary>
/// <remarks>The <c>client</c> variant of <see cref="TaskInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskInfoClient : TaskInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "client";

    /// <summary>ISO 8601 timestamp when the current active segment started.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("activeStartedAt")]
    public DateTimeOffset? ActiveStartedAt { get; set; }

    /// <summary>Accumulated active execution time in milliseconds.</summary>
    [JsonPropertyName("activeTimeMs")]
    public required long ActiveTimeMs { get; set; }

    /// <summary>Whether the currently bound owner can receive a cancellation request.</summary>
    [JsonPropertyName("canCancel")]
    public required bool CanCancel { get; set; }

    /// <summary>Human-readable reason for terminal cancellation.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cancellationReason")]
    public string? CancellationReason { get; set; }

    /// <summary>Owner-scoped registration and reclaim key.</summary>
    [JsonPropertyName("clientTaskId")]
    public required string ClientTaskId { get; set; }

    /// <summary>ISO 8601 timestamp when the task reached a terminal status.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("completedAt")]
    public DateTimeOffset? CompletedAt { get; set; }

    /// <summary>Task description.</summary>
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Optional task display name.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>Human-readable terminal failure message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Optional owner-supplied terminal failure code.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("errorCode")]
    public string? ErrorCode { get; set; }

    /// <summary>Execution mode, which is always background for client-owned tasks.</summary>
    [JsonPropertyName("executionMode")]
    public required TaskClientExecutionMode ExecutionMode { get; set; }

    /// <summary>Canonical runtime-generated task identifier.</summary>
    [JsonPropertyName("id")]
    public required string Id { get; set; }

    /// <summary>ISO 8601 timestamp when the connected owner entered idle status.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("idleSince")]
    public DateTimeOffset? IdleSince { get; set; }

    /// <summary>ISO 8601 timestamp of the most recent orphan transition.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("orphanedAt")]
    public DateTimeOffset? OrphanedAt { get; set; }

    /// <summary>Public attribution and presence for the task owner.</summary>
    [JsonPropertyName("owner")]
    public required TaskClientOwner Owner { get; set; }

    /// <summary>ISO 8601 timestamp of the most recent successful reclaim.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reclaimedAt")]
    public DateTimeOffset? ReclaimedAt { get; set; }

    /// <summary>Opaque successful terminal result supplied by the task owner.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }

    /// <summary>Sequence number of the latest accepted owner update.</summary>
    [JsonPropertyName("sequence")]
    public required long Sequence { get; set; }

    /// <summary>ISO 8601 timestamp when the task started.</summary>
    [JsonPropertyName("startedAt")]
    public required DateTimeOffset StartedAt { get; set; }

    /// <summary>Client task lifecycle status.</summary>
    [JsonPropertyName("status")]
    public required TaskClientStatus Status { get; set; }

    /// <summary>ISO 8601 timestamp of the latest accepted lifecycle change.</summary>
    [JsonPropertyName("updatedAt")]
    public required DateTimeOffset UpdatedAt { get; set; }
}

/// <summary>Tracked shell task metadata, including ID, command, status, timing, attachment/execution mode, log path, and PID.</summary>
/// <remarks>The <c>shell</c> variant of <see cref="TaskInfo"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskInfoShell : TaskInfo
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "shell";

    /// <summary>Whether the shell runs inside a managed PTY session or as an independent background process.</summary>
    [JsonPropertyName("attachmentMode")]
    public required TaskShellInfoAttachmentMode AttachmentMode { get; set; }

    /// <summary>Whether this shell task can be promoted to background mode.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("canPromoteToBackground")]
    public bool? CanPromoteToBackground { get; set; }

    /// <summary>Command being executed.</summary>
    [JsonPropertyName("command")]
    public required string Command { get; set; }

    /// <summary>ISO 8601 timestamp when the task finished.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("completedAt")]
    public DateTimeOffset? CompletedAt { get; set; }

    /// <summary>Short description of the task.</summary>
    [JsonPropertyName("description")]
    public required string Description { get; set; }

    /// <summary>Whether task execution is synchronously awaited or managed in the background.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("executionMode")]
    public TaskExecutionMode? ExecutionMode { get; set; }

    /// <summary>Unique task identifier.</summary>
    [JsonPropertyName("id")]
    public required string Id { get; set; }

    /// <summary>Path to the detached shell log, when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("logPath")]
    public string? LogPath { get; set; }

    /// <summary>Process ID when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pid")]
    public long? Pid { get; set; }

    /// <summary>ISO 8601 timestamp when the task was started.</summary>
    [JsonPropertyName("startedAt")]
    public required DateTimeOffset StartedAt { get; set; }

    /// <summary>Current lifecycle status of the task.</summary>
    [JsonPropertyName("status")]
    public required TaskStatus Status { get; set; }
}

/// <summary>Background tasks currently tracked by the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TaskList
{
    /// <summary>Currently tracked tasks.</summary>
    [JsonPropertyName("tasks")]
    public IList<TaskInfo> Tasks { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionTasksListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Tracked client-owned task metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TaskClientInfo
{
    /// <summary>ISO 8601 timestamp when the current active segment started.</summary>
    [JsonPropertyName("activeStartedAt")]
    public DateTimeOffset? ActiveStartedAt { get; set; }

    /// <summary>Accumulated active execution time in milliseconds.</summary>
    [JsonPropertyName("activeTimeMs")]
    public long ActiveTimeMs { get; set; }

    /// <summary>Whether the currently bound owner can receive a cancellation request.</summary>
    [JsonPropertyName("canCancel")]
    public bool CanCancel { get; set; }

    /// <summary>Human-readable reason for terminal cancellation.</summary>
    [JsonPropertyName("cancellationReason")]
    public string? CancellationReason { get; set; }

    /// <summary>Owner-scoped registration and reclaim key.</summary>
    [JsonPropertyName("clientTaskId")]
    public string ClientTaskId { get; set; } = string.Empty;

    /// <summary>ISO 8601 timestamp when the task reached a terminal status.</summary>
    [JsonPropertyName("completedAt")]
    public DateTimeOffset? CompletedAt { get; set; }

    /// <summary>Task description.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Optional task display name.</summary>
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>Human-readable terminal failure message.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Optional owner-supplied terminal failure code.</summary>
    [JsonPropertyName("errorCode")]
    public string? ErrorCode { get; set; }

    /// <summary>Execution mode, which is always background for client-owned tasks.</summary>
    [JsonPropertyName("executionMode")]
    public TaskClientExecutionMode ExecutionMode { get; set; }

    /// <summary>Canonical runtime-generated task identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>ISO 8601 timestamp when the connected owner entered idle status.</summary>
    [JsonPropertyName("idleSince")]
    public DateTimeOffset? IdleSince { get; set; }

    /// <summary>ISO 8601 timestamp of the most recent orphan transition.</summary>
    [JsonPropertyName("orphanedAt")]
    public DateTimeOffset? OrphanedAt { get; set; }

    /// <summary>Public attribution and presence for the task owner.</summary>
    [JsonPropertyName("owner")]
    public TaskClientOwner Owner { get => field ??= new(); set; }

    /// <summary>ISO 8601 timestamp of the most recent successful reclaim.</summary>
    [JsonPropertyName("reclaimedAt")]
    public DateTimeOffset? ReclaimedAt { get; set; }

    /// <summary>Opaque successful terminal result supplied by the task owner.</summary>
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }

    /// <summary>Sequence number of the latest accepted owner update.</summary>
    [JsonPropertyName("sequence")]
    public long Sequence { get; set; }

    /// <summary>ISO 8601 timestamp when the task started.</summary>
    [JsonPropertyName("startedAt")]
    public DateTimeOffset StartedAt { get; set; }

    /// <summary>Client task lifecycle status.</summary>
    [JsonPropertyName("status")]
    public TaskClientStatus Status { get; set; }

    /// <summary>Task kind.</summary>
    [JsonPropertyName("type")]
    public TaskClientType Type { get; set; }

    /// <summary>ISO 8601 timestamp of the latest accepted lifecycle change.</summary>
    [JsonPropertyName("updatedAt")]
    public DateTimeOffset UpdatedAt { get; set; }
}

/// <summary>Result of registering or reclaiming a client-owned task.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksRegisterResult
{
    /// <summary>True only when this invocation created a new task.</summary>
    [JsonPropertyName("created")]
    public bool Created { get; set; }

    /// <summary>True only when this invocation reclaimed an orphaned task.</summary>
    [JsonPropertyName("reclaimed")]
    public bool Reclaimed { get; set; }

    /// <summary>Authoritative registered or reclaimed task.</summary>
    [JsonPropertyName("task")]
    public TaskClientInfo Task { get => field ??= new(); set; }
}

/// <summary>Registers or reclaims a client-owned task.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksRegisterRequest
{
    /// <summary>Whether the owner supports runtime cancellation requests.</summary>
    [JsonPropertyName("cancellable")]
    public bool Cancellable { get; set; }

    /// <summary>Owner-scoped idempotency key used for registration and reclaim.</summary>
    [JsonPropertyName("clientTaskId")]
    public string ClientTaskId { get; set; } = string.Empty;

    /// <summary>Human-readable description of the external work.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Optional short display name for the external work.</summary>
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>Expected current sequence for idempotent registration or orphan reclaim.</summary>
    [JsonPropertyName("expectedSequence")]
    public long? ExpectedSequence { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Task kind.</summary>
    [JsonPropertyName("type")]
    public TaskClientType Type { get; set; }
}

/// <summary>Result of publishing a client-owned task update.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksUpdateResult
{
    /// <summary>Whether this invocation changed task state.</summary>
    [JsonPropertyName("applied")]
    public bool Applied { get; set; }

    /// <summary>Whether this invocation repeated the latest accepted update.</summary>
    [JsonPropertyName("duplicate")]
    public bool Duplicate { get; set; }

    /// <summary>Authoritative task after processing the update.</summary>
    [JsonPropertyName("task")]
    public TaskClientInfo Task { get => field ??= new(); set; }
}

/// <summary>Progress or terminal update for a client-owned task.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(TaskClientUpdateProgress), "progress")]
[JsonDerivedType(typeof(TaskClientUpdateCompleted), "completed")]
[JsonDerivedType(typeof(TaskClientUpdateFailed), "failed")]
[JsonDerivedType(typeof(TaskClientUpdateCancelled), "cancelled")]
public partial class TaskClientUpdate
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Publishes nonterminal progress for a running or idle client task.</summary>
/// <remarks>The <c>progress</c> variant of <see cref="TaskClientUpdate"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskClientUpdateProgress : TaskClientUpdate
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "progress";

    /// <summary>Optional progress message appended to recent activity when nonempty.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Optional completion percentage; null clears the current percentage.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("percentage")]
    public double? Percentage { get; set; }

    /// <summary>Optional progress phase; null clears the current phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("phase")]
    public string? Phase { get; set; }

    /// <summary>Optional active status transition.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("status")]
    public TaskClientActiveStatus? Status { get; set; }
}

/// <summary>Reports successful terminal completion.</summary>
/// <remarks>The <c>completed</c> variant of <see cref="TaskClientUpdate"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskClientUpdateCompleted : TaskClientUpdate
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "completed";

    /// <summary>Optional final progress message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Optional opaque successful terminal result.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }
}

/// <summary>Reports terminal failure.</summary>
/// <remarks>The <c>failed</c> variant of <see cref="TaskClientUpdate"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskClientUpdateFailed : TaskClientUpdate
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "failed";

    /// <summary>Optional owner-supplied terminal failure code.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("code")]
    public string? Code { get; set; }

    /// <summary>Human-readable terminal failure message.</summary>
    [JsonPropertyName("error")]
    public required string Error { get; set; }

    /// <summary>Optional final progress message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("message")]
    public string? Message { get; set; }
}

/// <summary>Reports terminal cancellation after external work stopped.</summary>
/// <remarks>The <c>cancelled</c> variant of <see cref="TaskClientUpdate"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskClientUpdateCancelled : TaskClientUpdate
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "cancelled";

    /// <summary>Optional final progress message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Optional human-readable cancellation reason.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }
}

/// <summary>Updates a client-owned task.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksUpdateRequest
{
    /// <summary>Canonical runtime-generated task identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Owner update sequence to apply.</summary>
    [JsonPropertyName("sequence")]
    public long Sequence { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Progress or terminal update payload.</summary>
    [JsonPropertyName("update")]
    public TaskClientUpdate Update { get => field ??= new(); set; }
}

/// <summary>Refresh metadata for any detached background shells the runtime knows about. Use after a long pause to pick up exit/output state for shells running outside the agent loop.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksRefreshResult
{
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionTasksRefreshRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Wait until all in-flight background tasks (agents + shells) and any follow-up turns scheduled by their completions have settled. Returns when the runtime is fully drained or after an internal timeout (default 10 minutes; configurable via COPILOT_TASK_WAIT_TIMEOUT_SECONDS).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksWaitForPendingResult
{
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionTasksWaitForPendingRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Progress information for the task, discriminated by type. Returns null when no task with this ID is currently tracked.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(TaskProgressAgent), "agent")]
[JsonDerivedType(typeof(TaskProgressClient), "client")]
[JsonDerivedType(typeof(TaskProgressShell), "shell")]
public partial class TaskProgress
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>Timestamped display line for task progress output or recent agent activity.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TaskProgressLine
{
    /// <summary>Display message, e.g., "▸ bash", "✓ edit src/foo.ts".</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>ISO 8601 timestamp when this event occurred.</summary>
    [JsonPropertyName("timestamp")]
    public DateTimeOffset Timestamp { get; set; }
}

/// <summary>Progress snapshot for an agent task, with recent activity lines and optional latest intent.</summary>
/// <remarks>The <c>agent</c> variant of <see cref="TaskProgress"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskProgressAgent : TaskProgress
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "agent";

    /// <summary>The most recent intent reported by the agent.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("latestIntent")]
    public string? LatestIntent { get; set; }

    /// <summary>Recent tool execution events converted to display lines.</summary>
    [JsonPropertyName("recentActivity")]
    public required IList<TaskProgressLine> RecentActivity { get; set; }
}

/// <summary>Generic progress for a client-owned task.</summary>
/// <remarks>The <c>client</c> variant of <see cref="TaskProgress"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskProgressClient : TaskProgress
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "client";

    /// <summary>Most recent nonempty progress message.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("lastMessage")]
    public string? LastMessage { get; set; }

    /// <summary>Current completion percentage from zero through one hundred.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("percentage")]
    public double? Percentage { get; set; }

    /// <summary>Current owner-defined progress phase.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("phase")]
    public string? Phase { get; set; }

    /// <summary>Recent server-timestamped progress messages.</summary>
    [JsonPropertyName("recentActivity")]
    public required IList<TaskProgressLine> RecentActivity { get; set; }

    /// <summary>Sequence number of the latest accepted owner update.</summary>
    [JsonPropertyName("sequence")]
    public required long Sequence { get; set; }

    /// <summary>Current client task lifecycle status.</summary>
    [JsonPropertyName("status")]
    public required TaskClientStatus Status { get; set; }

    /// <summary>ISO 8601 timestamp of the latest accepted lifecycle change.</summary>
    [JsonPropertyName("updatedAt")]
    public required DateTimeOffset UpdatedAt { get; set; }
}

/// <summary>Progress snapshot for a shell task, with recent stdout/stderr output and optional process ID.</summary>
/// <remarks>The <c>shell</c> variant of <see cref="TaskProgress"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class TaskProgressShell : TaskProgress
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "shell";

    /// <summary>Process ID when available.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("pid")]
    public long? Pid { get; set; }

    /// <summary>Recent stdout/stderr lines from the running shell command.</summary>
    [JsonPropertyName("recentOutput")]
    public required string RecentOutput { get; set; }
}

/// <summary>Progress information for the task, or null when no task with that ID is tracked.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksGetProgressResult
{
    /// <summary>Progress information for the task, discriminated by type. Returns null when no task with this ID is currently tracked.</summary>
    [JsonPropertyName("progress")]
    public TaskProgress? Progress { get; set; }
}

/// <summary>Identifier of the background task to fetch progress for.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksGetProgressRequest
{
    /// <summary>Task identifier (agent ID or shell ID).</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The first sync-waiting task that can currently be promoted to background mode.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksGetCurrentPromotableResult
{
    /// <summary>The first sync-waiting task (agent first, then shell) that can currently be promoted to background mode. Omitted if no such task exists. The returned task is guaranteed to have executionMode='sync' and canPromoteToBackground=true at the time of the call.</summary>
    [JsonPropertyName("task")]
    public TaskInfo? Task { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionTasksGetCurrentPromotableRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the task was successfully promoted to background mode.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksPromoteToBackgroundResult
{
    /// <summary>Whether the task was successfully promoted to background mode.</summary>
    [JsonPropertyName("promoted")]
    public bool Promoted { get; set; }
}

/// <summary>Identifier of the task to promote to background mode.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksPromoteToBackgroundRequest
{
    /// <summary>Task identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The promoted task as it now exists in background mode, omitted if no promotable task was waiting.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksPromoteCurrentToBackgroundResult
{
    /// <summary>The promoted task as it now exists in background mode, omitted if no promotable task was waiting. Atomic operation: avoids the race window of getCurrentPromotable + promoteToBackground.</summary>
    [JsonPropertyName("task")]
    public TaskInfo? Task { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionTasksPromoteCurrentToBackgroundRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the background task was successfully cancelled.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksCancelResult
{
    /// <summary>Whether the task was successfully cancelled.</summary>
    [JsonPropertyName("cancelled")]
    public bool Cancelled { get; set; }
}

/// <summary>Identifier of the background task to cancel.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksCancelRequest
{
    /// <summary>Task identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the task was removed. False when the task does not exist or is still running/idle.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksRemoveResult
{
    /// <summary>Whether the task was removed. Returns false if the task does not exist or is still running/idle (cancel it first).</summary>
    [JsonPropertyName("removed")]
    public bool Removed { get; set; }
}

/// <summary>Identifier of the completed or cancelled task to remove from tracking.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksRemoveRequest
{
    /// <summary>Task identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the message was delivered, with an error message when delivery failed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksSendMessageResult
{
    /// <summary>Error message if delivery failed.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Whether the message was successfully delivered or steered.</summary>
    [JsonPropertyName("sent")]
    public bool Sent { get; set; }
}

/// <summary>Identifier of the target agent task, message content, and optional sender agent ID.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TasksSendMessageRequest
{
    /// <summary>Agent ID of the sender, if sent on behalf of another agent.</summary>
    [JsonPropertyName("fromAgentId")]
    public string? FromAgentId { get; set; }

    /// <summary>Agent task identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Message content to send to the agent.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Skill metadata available to a session, with name, description, source, enabled/invocable state, path, plugin, and argument hint.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class Skill
{
    /// <summary>Optional freeform hint describing the skill's expected arguments, from the `argument-hint` frontmatter field.</summary>
    [JsonPropertyName("argumentHint")]
    public string? ArgumentHint { get; set; }

    /// <summary>Canonical slash command name used to invoke the skill, without the leading '/'.</summary>
    [JsonPropertyName("commandName")]
    public string? CommandName { get; set; }

    /// <summary>Description of what the skill does.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Whether the skill is currently enabled.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Unique identifier for the skill.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Absolute path to the skill file.</summary>
    [JsonPropertyName("path")]
    public string? Path { get; set; }

    /// <summary>Name of the plugin that provides the skill, when source is 'plugin'.</summary>
    [JsonPropertyName("pluginName")]
    public string? PluginName { get; set; }

    /// <summary>Source location type (e.g., project, personal-copilot, plugin, builtin).</summary>
    [JsonPropertyName("source")]
    public SkillSource Source { get; set; }

    /// <summary>Whether the skill can be invoked by the user as a slash command.</summary>
    [JsonPropertyName("userInvocable")]
    public bool UserInvocable { get; set; }
}

/// <summary>Skills available to the session, with their enabled state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SkillList
{
    /// <summary>Available skills.</summary>
    [JsonPropertyName("skills")]
    public IList<Skill> Skills { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSkillsListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Skill invocation record with name, path, content, allowed tools, and turn number.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SkillsInvokedSkill
{
    /// <summary>Tools that should be auto-approved when this skill is active, captured at invocation time.</summary>
    [JsonPropertyName("allowedTools")]
    public IList<string>? AllowedTools { get; set; }

    /// <summary>Full content of the skill file.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Whether model invocation was disabled when this skill was invoked.</summary>
    [JsonPropertyName("disableModelInvocation")]
    public bool? DisableModelInvocation { get; set; }

    /// <summary>Turn number when the skill was invoked.</summary>
    [JsonPropertyName("invokedAtTurn")]
    public long InvokedAtTurn { get; set; }

    /// <summary>Unique identifier for the skill.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Path to the SKILL.md file, or an empty string for an SDK-provided skill without a filesystem identity.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;
}

/// <summary>Skills invoked during this session, ordered by invocation time (most recent last).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SkillsGetInvokedResult
{
    /// <summary>Skills invoked during this session, ordered by invocation time (most recent last).</summary>
    [JsonPropertyName("skills")]
    public IList<SkillsInvokedSkill> Skills { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSkillsGetInvokedRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Name of the skill to enable for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SkillsEnableRequest
{
    /// <summary>Name of the skill to enable.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Name of the skill to disable for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SkillsDisableRequest
{
    /// <summary>Name of the skill to disable.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Diagnostics from reloading skill definitions, with warnings and errors as separate lists.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SkillsLoadDiagnostics
{
    /// <summary>Errors emitted while loading skills (e.g. skills that failed to load entirely).</summary>
    [JsonPropertyName("errors")]
    public IList<string> Errors { get => field ??= []; set; }

    /// <summary>Warnings emitted while loading skills (e.g. skills that loaded but had issues).</summary>
    [JsonPropertyName("warnings")]
    public IList<string> Warnings { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSkillsReloadRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSkillsEnsureLoadedRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Recorded MCP server connection failure.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpServerFailureInfo
{
    /// <summary>Failure message produced when the MCP server connection failed.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>epoch-ms timestamp at which the failure was recorded.</summary>
    [JsonPropertyName("timestamp")]
    public long Timestamp { get; set; }
}

/// <summary>Recorded MCP server pending-auth state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpServerNeedsAuthInfo
{
    /// <summary>epoch-ms timestamp at which the server signalled it needs authentication.</summary>
    [JsonPropertyName("timestamp")]
    public long Timestamp { get; set; }
}

/// <summary>Host-level state, omitted when no MCP host is initialized.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpHostState
{
    /// <summary>Names of currently-connected MCP clients.</summary>
    [JsonPropertyName("clients")]
    public IList<string> Clients { get => field ??= []; set; }

    /// <summary>Configured servers that are explicitly disabled.</summary>
    [JsonPropertyName("disabledServers")]
    public IList<string> DisabledServers { get => field ??= []; set; }

    /// <summary>Map of server name to recorded connection failure.</summary>
    [JsonPropertyName("failedServers")]
    public IDictionary<string, McpServerFailureInfo> FailedServers { get => field ??= new Dictionary<string, McpServerFailureInfo>(); set; }

    /// <summary>Configured servers filtered out by MCP server policy.</summary>
    [JsonPropertyName("filteredServers")]
    public IList<string> FilteredServers { get => field ??= []; set; }

    /// <summary>Whether third-party MCP servers are policy-enabled for this session.</summary>
    [JsonPropertyName("mcp3pEnabled")]
    public bool Mcp3pEnabled { get; set; }

    /// <summary>Map of server name to recorded pending-auth state.</summary>
    [JsonPropertyName("needsAuthServers")]
    public IDictionary<string, McpServerNeedsAuthInfo> NeedsAuthServers { get => field ??= new Dictionary<string, McpServerNeedsAuthInfo>(); set; }

    /// <summary>Names of servers with in-flight connection attempts.</summary>
    [JsonPropertyName("pendingConnections")]
    public IList<string> PendingConnections { get => field ??= []; set; }
}

/// <summary>MCP server status entry, including config source/plugin source and any connection error.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpServer
{
    /// <summary>Error message if the server failed to connect.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Server name (config key).</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Server-advertised metadata for a connected server. Omitted when no live connection metadata is available, including while pending or when failed, disabled, stopped, or not configured.</summary>
    [JsonPropertyName("serverMetadata")]
    public McpServerMetadata? ServerMetadata { get; set; }

    /// <summary>Configuration source: user, workspace, plugin, or builtin.</summary>
    [JsonPropertyName("source")]
    public McpServerSource? Source { get; set; }

    /// <summary>Plugin name that provided this server, when source is plugin.</summary>
    [JsonPropertyName("sourcePlugin")]
    public string? SourcePlugin { get; set; }

    /// <summary>Plugin version that provided this server, when source is plugin.</summary>
    [JsonPropertyName("sourcePluginVersion")]
    public string? SourcePluginVersion { get; set; }

    /// <summary>Connection status: connected, failed, needs-auth, pending, disabled, stopped, or not_configured.</summary>
    [JsonPropertyName("status")]
    public McpServerStatus Status { get; set; }
}

/// <summary>MCP servers configured for the session, with their connection status and host-level state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpServerList
{
    /// <summary>Host-level state, omitted when no MCP host is initialized.</summary>
    [JsonPropertyName("host")]
    public McpHostState? Host { get; set; }

    /// <summary>Configured MCP servers.</summary>
    [JsonPropertyName("servers")]
    public IList<McpServer> Servers { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMcpListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Normalized MCP Apps discovery metadata from a tool's `_meta.ui` block.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpToolUi
{
    /// <summary>URI of the tool's MCP App resource, typically a `ui://` resource identifier. Use `session.mcp.resources.read` to fetch its HTML and resource metadata.</summary>
    [JsonPropertyName("resourceUri")]
    public string? ResourceUri { get; set; }

    /// <summary>Tool visibility advertised by the server. When absent, MCP Apps defaults apply.</summary>
    [JsonPropertyName("visibility")]
    public IList<McpToolUiVisibility>? Visibility { get; set; }
}

/// <summary>MCP tool metadata with tool name, optional description, and normalized MCP Apps discovery metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpTools
{
    /// <summary>Tool description, when provided.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Tool name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Normalized MCP Apps discovery metadata. An empty object indicates that a valid `_meta.ui` block was present without recognized fields.</summary>
    [JsonPropertyName("ui")]
    public McpToolUi? Ui { get; set; }
}

/// <summary>Tools exposed by the connected MCP server. Throws when the server is not connected.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpListToolsResult
{
    /// <summary>Tools exposed by the server.</summary>
    [JsonPropertyName("tools")]
    public IList<McpTools> Tools { get => field ??= []; set; }
}

/// <summary>Server name whose tool list should be returned.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpListToolsRequest
{
    /// <summary>Name of the connected MCP server whose tools to list.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Name of the MCP server to enable for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpEnableRequest
{
    /// <summary>Name of the MCP server to enable.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Name of the MCP server to disable for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpDisableRequest
{
    /// <summary>Name of the MCP server to disable.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMcpReloadRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of moving in-flight MCP loading to the background.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MoveMcpLoadingToBackgroundResult
{
    /// <summary>Whether an in-flight MCP load was moved to the background, releasing turns that were waiting on it. False when no MCP load was in flight or the waiting turns had already been released.</summary>
    [JsonPropertyName("movedToBackground")]
    public bool MovedToBackground { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMcpMoveLoadingToBackgroundRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>MCP server allowed by policy, with server name and optional PII-free explanatory note.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAllowedServer
{
    /// <summary>Allowed server name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>PII-free note explaining why the server was allowed.</summary>
    [JsonPropertyName("redactedNote")]
    public string? RedactedNote { get; set; }
}

/// <summary>MCP server whose connection attempt failed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpFailedServer
{
    /// <summary>The captured connection failure detail.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>The config key of the server that failed to connect.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>MCP server filtered by policy, with name, reason, and optional redacted reason.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpFilteredServer
{
    /// <summary>Deprecated. This field is no longer populated.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonPropertyName("enterpriseName")]
    public string? EnterpriseName { get; set; }

    /// <summary>Filtered server name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Human-readable filter reason.</summary>
    [JsonPropertyName("reason")]
    public string Reason { get; set; } = string.Empty;

    /// <summary>PII-free filter reason.</summary>
    [JsonPropertyName("redactedReason")]
    public string? RedactedReason { get; set; }
}

/// <summary>MCP server startup filtering result.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpStartServersResult
{
    /// <summary>Non-default servers allowed by policy.</summary>
    [JsonPropertyName("allowedServers")]
    public IList<McpAllowedServer>? AllowedServers { get; set; }

    /// <summary>Servers whose connection attempt failed.</summary>
    [JsonPropertyName("failedServers")]
    public IList<McpFailedServer>? FailedServers { get; set; }

    /// <summary>Servers filtered out before startup.</summary>
    [JsonPropertyName("filteredServers")]
    public IList<McpFilteredServer> FilteredServers { get => field ??= []; set; }
}

/// <summary>Opaque MCP reload configuration.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpReloadWithConfigRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>MCP CreateMessageResult payload (with optional 'tools' extension), present when action='success'. Treated as opaque at the schema layer; consumers should construct/consume it per the MCP CreateMessageResult shape.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpExecuteSamplingResult
{
}

/// <summary>Outcome of an MCP sampling execution: success result, failure error, or cancellation.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpSamplingExecutionResult
{
    /// <summary>Outcome of the sampling inference. 'success' produced a response; 'failure' encountered an error (including agent-side rejection by content filter or criteria); 'cancelled' the caller cancelled this execution via cancelSamplingExecution.</summary>
    [JsonPropertyName("action")]
    public McpSamplingExecutionAction Action { get; set; }

    /// <summary>Error description, present when action='failure'.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>MCP CreateMessageResult payload (with optional 'tools' extension), present when action='success'. Treated as opaque at the schema layer; consumers should construct/consume it per the MCP CreateMessageResult shape.</summary>
    [JsonPropertyName("result")]
    public McpExecuteSamplingResult? Result { get; set; }
}

/// <summary>Raw MCP CreateMessageRequest params, as received in the `sampling.requested` event. Treated as opaque at the schema layer; the runtime converts the embedded MCP messages into the OpenAI chat-completion shape internally.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpExecuteSamplingRequest
{
}

/// <summary>Identifiers and raw MCP CreateMessageRequest params used to run a sampling inference.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpExecuteSamplingParams
{
    /// <summary>The original MCP JSON-RPC request ID (string or number). Used by the runtime to correlate the inference with the originating MCP request for telemetry; this is distinct from `requestId` (which is the schema-level cancellation handle).</summary>
    [JsonPropertyName("mcpRequestId")]
    public JsonElement McpRequestId { get; set; }

    /// <summary>Raw MCP CreateMessageRequest params, as received in the `sampling.requested` event. Treated as opaque at the schema layer; the runtime converts the embedded MCP messages into the OpenAI chat-completion shape internally.</summary>
    [JsonPropertyName("request")]
    public McpExecuteSamplingRequest Request { get => field ??= new(); set; }

    /// <summary>Caller-provided unique identifier for this sampling execution. Use this same ID with cancelSamplingExecution to cancel the in-flight call. Must be unique within the session for the lifetime of the call.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Name of the MCP server that initiated the sampling request.</summary>
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether an in-flight sampling execution with the given requestId was found and cancelled.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpCancelSamplingExecutionResult
{
    /// <summary>True if an in-flight execution with the given requestId was found and signalled to cancel. False when no such execution is in flight (already completed, never started, or cancelled by another caller).</summary>
    [JsonPropertyName("cancelled")]
    public bool Cancelled { get; set; }
}

/// <summary>The requestId previously passed to executeSampling that should be cancelled.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpCancelSamplingExecutionParams
{
    /// <summary>The requestId previously passed to executeSampling that should be cancelled.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Env-value mode recorded on the session after the update.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpSetEnvValueModeResult
{
    /// <summary>Mode recorded on the session after the update.</summary>
    [JsonPropertyName("mode")]
    public McpSetEnvValueModeDetails Mode { get; set; }
}

/// <summary>Mode controlling how MCP server env values are resolved (`direct` or `indirect`).</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpSetEnvValueModeParams
{
    /// <summary>How environment-variable values supplied to MCP servers are resolved. "direct" passes literal string values; "indirect" treats values as references (e.g. names of environment variables on the host) that the runtime resolves before launch. Defaults to the runtime's startup mode; clients that intentionally launch MCP servers with literal values (e.g. CLI prompt mode and ACP) set this to "direct".</summary>
    [JsonPropertyName("mode")]
    public McpSetEnvValueModeDetails Mode { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpRemoveGitHubResult
{
    /// <summary>True when the auto-managed `github` MCP server was removed; false when no removal happened (e.g. user has explicitly configured a `github` server, or the server was not registered).</summary>
    [JsonPropertyName("removed")]
    public bool Removed { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMcpRemoveGitHubRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of configuring GitHub MCP.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpConfigureGitHubResult
{
    /// <summary>Whether GitHub MCP configuration changed.</summary>
    [JsonPropertyName("changed")]
    public bool Changed { get; set; }
}

/// <summary>Credential-free authentication identity used to configure GitHub MCP.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpConfigureGitHubRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Server name and optional configuration for an individual MCP server start. Omit `config` for a config-free start-by-name of an already-configured server.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpStartServerRequest
{
    /// <summary>MCP server configuration (stdio process or remote HTTP/SSE). Omit to start the server with its already-registered configuration (config-free start-by-name).</summary>
    [JsonPropertyName("config")]
    public JsonElement? Config { get; set; }

    /// <summary>Name of the MCP server to start.</summary>
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Server name and optional replacement configuration for an individual MCP server restart. Omit `config` for a config-free restart-by-name of an already-configured server.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpRestartServerRequest
{
    /// <summary>Replacement MCP server configuration (stdio process or remote HTTP/SSE). Omit to restart the server with its already-registered configuration (config-free restart-by-name).</summary>
    [JsonPropertyName("config")]
    public JsonElement? Config { get; set; }

    /// <summary>Name of the MCP server to restart.</summary>
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Server name for an individual MCP server stop.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpStopServerRequest
{
    /// <summary>Name of the MCP server to stop.</summary>
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Registration parameters for an external MCP client.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpRegisterExternalClientRequest
{
    /// <summary>Logical server name for the external client.</summary>
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Server name identifying the external client to remove.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpUnregisterExternalClientRequest
{
    /// <summary>Server name of the external client to unregister.</summary>
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Whether the named MCP server is running.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpIsServerRunningResult
{
    /// <summary>True if the server has an active client and transport.</summary>
    [JsonPropertyName("running")]
    public bool Running { get; set; }
}

/// <summary>Server name to check running status for.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpIsServerRunningRequest
{
    /// <summary>Name of the MCP server to check.</summary>
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the pending MCP OAuth response was accepted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpOauthHandlePendingResult
{
    /// <summary>Whether the response was accepted. False if the request was unknown, timed out, or already resolved.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Host response to the pending OAuth request.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpOauthPendingRequestResponseToken), "token")]
[JsonDerivedType(typeof(McpOauthPendingRequestResponseCancelled), "cancelled")]
public partial class McpOauthPendingRequestResponse
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>The <c>token</c> variant of <see cref="McpOauthPendingRequestResponse"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpOauthPendingRequestResponseToken : McpOauthPendingRequestResponse
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "token";

    /// <summary>Access token acquired by the SDK host.</summary>
    [JsonPropertyName("accessToken")]
    public required string AccessToken { get; set; }

    /// <summary>Token lifetime in seconds, if known.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("expiresIn")]
    public long? ExpiresIn { get; set; }

    /// <summary>OAuth token type. Defaults to bearer when omitted.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tokenType")]
    public string? TokenType { get; set; }
}

/// <summary>The <c>cancelled</c> variant of <see cref="McpOauthPendingRequestResponse"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpOauthPendingRequestResponseCancelled : McpOauthPendingRequestResponse
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "cancelled";
}

/// <summary>Pending MCP OAuth request ID and host-provided token or cancellation response.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpOauthHandlePendingRequest
{
    /// <summary>OAuth request identifier from the mcp.oauth_required event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Host response to the pending OAuth request.</summary>
    [JsonPropertyName("result")]
    public McpOauthPendingRequestResponse Result { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the MCP server whose persisted OAuth credentials were updated.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpOauthAuthenticationStateChangedRequest
{
    /// <summary>Whether the target session must mint a session-scoped access token instead of reusing a shared access token persisted by another session.</summary>
    [JsonPropertyName("refreshSessionToken")]
    public bool? RefreshSessionToken { get; set; }

    /// <summary>Name of the MCP server whose OAuth credentials were updated. Omit only when the host cannot identify the server.</summary>
    [JsonPropertyName("serverName")]
    public string? ServerName { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpOauthLoginResult
{
    /// <summary>URL the caller should open in a browser to complete OAuth. Omitted when cached tokens were still valid and no browser interaction was needed — the server is already reconnected in that case. When present, the runtime starts the callback listener before returning and continues the flow in the background; completion is signaled via session.mcp_server_status_changed.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("authorizationUrl")]
    public string? AuthorizationUrl { get; set; }
}

/// <summary>Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpOauthLoginRequest
{
    /// <summary>Optional override for the body text shown on the OAuth loopback callback success page. When omitted, the runtime applies a neutral fallback; callers driving interactive auth should pass surface-specific copy telling the user where to return.</summary>
    [JsonPropertyName("callbackSuccessMessage")]
    public string? CallbackSuccessMessage { get; set; }

    /// <summary>Optional OAuth client ID override for this login. When set, the runtime uses this pre-registered static client instead of dynamic client registration.</summary>
    [JsonPropertyName("clientId")]
    public string? ClientId { get; set; }

    /// <summary>Optional override for the OAuth client display name shown on the consent screen. Applies to newly registered dynamic clients only — existing registrations keep the name they were created with. When omitted, the runtime applies a neutral fallback; callers driving interactive auth should pass their own surface-specific label so the consent screen matches the product the user sees.</summary>
    [JsonPropertyName("clientName")]
    public string? ClientName { get; set; }

    /// <summary>Optional OAuth client secret override for this login. The runtime treats this as an ephemeral host-owned secret, uses it for this authentication attempt and does not persist it.</summary>
    [JsonPropertyName("clientSecret")]
    public string? ClientSecret { get; set; }

    /// <summary>When true, clears any cached OAuth token for the server and runs a full new authorization. Use when the user explicitly wants to switch accounts or believes their session is stuck.</summary>
    [JsonPropertyName("forceReauth")]
    public bool? ForceReauth { get; set; }

    /// <summary>Optional OAuth grant type override for this login. Defaults to the server configuration, or authorization_code when no grant type is specified.</summary>
    [JsonPropertyName("grantType")]
    public McpOauthLoginGrantType? GrantType { get; set; }

    /// <summary>Optional override indicating whether the static OAuth client is public. When false, the runtime treats it as confidential and uses the per-login clientSecret if provided, otherwise retrieving the client secret from the MCP OAuth secret store.</summary>
    [JsonPropertyName("publicClient")]
    public bool? PublicClient { get; set; }

    /// <summary>Name of the remote MCP server to authenticate.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Passive MCP OAuth probe result. `authenticated` means the server accepted the probe request while an OAuth-origin access token was attached; it does not prove the server required or independently validated that token. The probe does not make a second unauthenticated request. Failed is an expected probe-domain outcome; JSON-RPC errors are reserved for API-call failures.</summary>
/// <remarks>Polymorphic base type discriminated by <c>status</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "status",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpOauthProbeResultNoAuthRequired), "no-auth-required")]
[JsonDerivedType(typeof(McpOauthProbeResultAuthenticated), "authenticated")]
[JsonDerivedType(typeof(McpOauthProbeResultNeedsAuth), "needs-auth")]
[JsonDerivedType(typeof(McpOauthProbeResultFailed), "failed")]
public partial class McpOauthProbeResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("status")]
    public virtual string Status { get; set; } = string.Empty;
}


/// <summary>The <c>no-auth-required</c> variant of <see cref="McpOauthProbeResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpOauthProbeResultNoAuthRequired : McpOauthProbeResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "no-auth-required";

    /// <summary>HTTP response returned by the server.</summary>
    [JsonPropertyName("httpResponse")]
    public required McpOauthHttpResponse HttpResponse { get; set; }
}

/// <summary>The <c>authenticated</c> variant of <see cref="McpOauthProbeResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpOauthProbeResultAuthenticated : McpOauthProbeResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "authenticated";

    /// <summary>HTTP response returned by the server.</summary>
    [JsonPropertyName("httpResponse")]
    public required McpOauthHttpResponse HttpResponse { get; set; }
}

/// <summary>The <c>needs-auth</c> variant of <see cref="McpOauthProbeResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpOauthProbeResultNeedsAuth : McpOauthProbeResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "needs-auth";

    /// <summary>HTTP 401 or 403 response returned by the server.</summary>
    [JsonPropertyName("httpResponse")]
    public required McpOauthHttpResponse HttpResponse { get; set; }

    /// <summary>Why authentication is needed.</summary>
    [JsonPropertyName("reason")]
    public required McpOauthProbeNeedsAuthReason Reason { get; set; }

    /// <summary>Parsed WWW-Authenticate challenge parameters, when present and parseable.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("wwwAuthenticateParams")]
    public McpOauthWWWAuthenticateParams? WwwAuthenticateParams { get; set; }
}

/// <summary>The <c>failed</c> variant of <see cref="McpOauthProbeResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpOauthProbeResultFailed : McpOauthProbeResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Status => "failed";

    /// <summary>Human-readable probe failure detail.</summary>
    [JsonPropertyName("error")]
    public required string Error { get; set; }

    /// <summary>HTTP response returned by the server, when the probe reached the server and captured the complete response.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("httpResponse")]
    public McpOauthHttpResponse? HttpResponse { get; set; }
}

/// <summary>Remote MCP server name for a passive OAuth status probe.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpOauthProbeRequest
{
    /// <summary>Name of the configured remote MCP server to probe.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the pending MCP OAuth response was accepted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpOauthRespondResult
{
    /// <summary>Whether the response was accepted. False if the request was unknown, timed out, or already resolved.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Pending MCP OAuth request id to respond to.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpOauthRespondRequest
{
    /// <summary>OAuth request identifier from the mcp.oauth_required event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the pending MCP headers refresh response was accepted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpHeadersHandlePendingHeadersRefreshRequestResult
{
    /// <summary>Whether the response was accepted. False if the request was unknown, timed out, or already resolved.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Host response: supply dynamic headers or decline this refresh.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(McpHeadersHandlePendingHeadersRefreshRequestHeaders), "headers")]
[JsonDerivedType(typeof(McpHeadersHandlePendingHeadersRefreshRequestNone), "none")]
public partial class McpHeadersHandlePendingHeadersRefreshRequest
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>The <c>headers</c> variant of <see cref="McpHeadersHandlePendingHeadersRefreshRequest"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpHeadersHandlePendingHeadersRefreshRequestHeaders : McpHeadersHandlePendingHeadersRefreshRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "headers";

    /// <summary>Headers to overlay onto the MCP request. Dynamic headers override static config headers but do not replace SDK-managed request headers.</summary>
    [JsonPropertyName("headers")]
    public required IDictionary<string, string> Headers { get; set; }
}

/// <summary>The <c>none</c> variant of <see cref="McpHeadersHandlePendingHeadersRefreshRequest"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class McpHeadersHandlePendingHeadersRefreshRequestNone : McpHeadersHandlePendingHeadersRefreshRequest
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "none";
}

/// <summary>MCP headers refresh request id and the host response.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpHeadersHandlePendingHeadersRefreshRequestRequest
{
    /// <summary>Headers refresh request identifier from mcp.headers_refresh_required.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Host response: supply dynamic headers or decline this refresh.</summary>
    [JsonPropertyName("result")]
    public McpHeadersHandlePendingHeadersRefreshRequest Result { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>MCP Apps resource content with URI, optional MIME type, text or base64 blob, and resource metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsResourceContent
{
    /// <summary>Resource-level metadata (CSP, permissions, etc.).</summary>
    [JsonPropertyName("_meta")]
    public IDictionary<string, JsonElement>? Meta { get; set; }

    /// <summary>Base64-encoded binary content.</summary>
    [JsonPropertyName("blob")]
    public string? Blob { get; set; }

    /// <summary>MIME type of the content.</summary>
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Text content (e.g. HTML).</summary>
    [JsonPropertyName("text")]
    public string? Text { get; set; }

    /// <summary>The resource URI (typically ui://...).</summary>
    [JsonPropertyName("uri")]
    public string Uri { get; set; } = string.Empty;
}

/// <summary>Resource contents returned by the MCP server.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsReadResourceResult
{
    /// <summary>Resource contents returned by the server.</summary>
    [JsonPropertyName("contents")]
    public IList<McpAppsResourceContent> Contents { get => field ??= []; set; }
}

/// <summary>MCP server and resource URI to fetch.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpAppsReadResourceRequest
{
    /// <summary>Name of the MCP server hosting the resource.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Resource URI (typically ui://...).</summary>
    [JsonPropertyName("uri")]
    public string Uri { get; set; } = string.Empty;
}

/// <summary>App-callable tools from the named MCP server.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsListToolsResult
{
    /// <summary>App-callable tools from the server.</summary>
    [JsonPropertyName("tools")]
    public IList<IDictionary<string, JsonElement>> Tools { get => field ??= []; set; }
}

/// <summary>MCP server to list app-callable tools for.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpAppsListToolsRequest
{
    /// <summary>**Required.** Server whose ui:// view issued the request. Per SEP-1865 ('callable by the app from this server only'), the call is rejected when this differs from `serverName`, and rejected outright when missing.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("originServerName")]
    public string OriginServerName { get; set; } = string.Empty;

    /// <summary>MCP server hosting the app.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>MCP server, tool name, and arguments to invoke from an MCP App view.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpAppsCallToolRequest
{
    /// <summary>Tool arguments.</summary>
    [JsonPropertyName("arguments")]
    public IDictionary<string, JsonElement>? Arguments { get; set; }

    /// <summary>**Required.** Server whose ui:// view issued the request. Per SEP-1865 ('callable by the app from this server only'), the call is rejected when this differs from `serverName`, and rejected outright when missing.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("originServerName")]
    public string OriginServerName { get; set; } = string.Empty;

    /// <summary>MCP server hosting the tool.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>MCP tool name.</summary>
    [JsonPropertyName("toolName")]
    public string ToolName { get; set; } = string.Empty;
}

/// <summary>Host context advertised to MCP App guests.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsSetHostContextDetails
{
    /// <summary>Display modes the host supports.</summary>
    [JsonPropertyName("availableDisplayModes")]
    public IList<McpAppsSetHostContextDetailsAvailableDisplayMode>? AvailableDisplayModes { get; set; }

    /// <summary>Current display mode (SEP-1865).</summary>
    [JsonPropertyName("displayMode")]
    public McpAppsSetHostContextDetailsDisplayMode? DisplayMode { get; set; }

    /// <summary>BCP-47 locale, e.g. 'en-US'.</summary>
    [JsonPropertyName("locale")]
    public string? Locale { get; set; }

    /// <summary>Platform type for responsive design.</summary>
    [JsonPropertyName("platform")]
    public McpAppsSetHostContextDetailsPlatform? Platform { get; set; }

    /// <summary>UI theme preference per SEP-1865.</summary>
    [JsonPropertyName("theme")]
    public McpAppsSetHostContextDetailsTheme? Theme { get; set; }

    /// <summary>IANA timezone, e.g. 'America/New_York'.</summary>
    [JsonPropertyName("timeZone")]
    public string? TimeZone { get; set; }

    /// <summary>Host application identifier.</summary>
    [JsonPropertyName("userAgent")]
    public string? UserAgent { get; set; }
}

/// <summary>Host context to advertise to MCP App guests.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpAppsSetHostContextRequest
{
    /// <summary>Host context advertised to MCP App guests.</summary>
    [JsonPropertyName("context")]
    public McpAppsSetHostContextDetails Context { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Current host context.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsHostContextDetails
{
    /// <summary>Display modes the host supports.</summary>
    [JsonPropertyName("availableDisplayModes")]
    public IList<McpAppsHostContextDetailsAvailableDisplayMode>? AvailableDisplayModes { get; set; }

    /// <summary>Current display mode (SEP-1865).</summary>
    [JsonPropertyName("displayMode")]
    public McpAppsHostContextDetailsDisplayMode? DisplayMode { get; set; }

    /// <summary>BCP-47 locale, e.g. 'en-US'.</summary>
    [JsonPropertyName("locale")]
    public string? Locale { get; set; }

    /// <summary>Platform type for responsive design.</summary>
    [JsonPropertyName("platform")]
    public McpAppsHostContextDetailsPlatform? Platform { get; set; }

    /// <summary>UI theme preference per SEP-1865.</summary>
    [JsonPropertyName("theme")]
    public McpAppsHostContextDetailsTheme? Theme { get; set; }

    /// <summary>IANA timezone, e.g. 'America/New_York'.</summary>
    [JsonPropertyName("timeZone")]
    public string? TimeZone { get; set; }

    /// <summary>Host application identifier.</summary>
    [JsonPropertyName("userAgent")]
    public string? UserAgent { get; set; }
}

/// <summary>Current host context advertised to MCP App guests.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsHostContext
{
    /// <summary>Current host context.</summary>
    [JsonPropertyName("context")]
    public McpAppsHostContextDetails Context { get => field ??= new(); set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMcpAppsGetHostContextRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Capability negotiation snapshot.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsDiagnoseCapability
{
    /// <summary>Whether the runtime advertises `extensions.io.modelcontextprotocol/ui` to MCP servers.</summary>
    [JsonPropertyName("advertised")]
    public bool Advertised { get; set; }

    /// <summary>Whether the MCP_APPS feature flag (or COPILOT_MCP_APPS env override) is on.</summary>
    [JsonPropertyName("featureFlagEnabled")]
    public bool FeatureFlagEnabled { get; set; }

    /// <summary>Whether the session has the `mcp-apps` capability.</summary>
    [JsonPropertyName("sessionHasMcpApps")]
    public bool SessionHasMcpApps { get; set; }
}

/// <summary>What the server returned for this session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsDiagnoseServer
{
    /// <summary>Whether the named server is currently connected.</summary>
    [JsonPropertyName("connected")]
    public bool Connected { get; set; }

    /// <summary>Up to 5 tool names with `_meta.ui` for quick inspection.</summary>
    [JsonPropertyName("sampleToolNames")]
    public IList<string> SampleToolNames { get => field ??= []; set; }

    /// <summary>Total tools returned by the server's tools/list.</summary>
    [JsonPropertyName("toolCount")]
    public double ToolCount { get; set; }

    /// <summary>Tools whose `_meta.ui` is populated (resourceUri and/or visibility set).</summary>
    [JsonPropertyName("toolsWithUiMeta")]
    public double ToolsWithUiMeta { get; set; }
}

/// <summary>Diagnostic snapshot of MCP Apps wiring for the named server.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsDiagnoseResult
{
    /// <summary>Capability negotiation snapshot.</summary>
    [JsonPropertyName("capability")]
    public McpAppsDiagnoseCapability Capability { get => field ??= new(); set; }

    /// <summary>What the server returned for this session.</summary>
    [JsonPropertyName("server")]
    public McpAppsDiagnoseServer Server { get => field ??= new(); set; }
}

/// <summary>MCP server to diagnose MCP Apps wiring for.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpAppsDiagnoseRequest
{
    /// <summary>MCP server to probe.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>MCP resource content with URI, optional MIME type, text or base64 blob, and resource metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourceContent
{
    /// <summary>Resource-level metadata (CSP, permissions, etc.).</summary>
    [JsonPropertyName("_meta")]
    public IDictionary<string, JsonElement>? Meta { get; set; }

    /// <summary>Base64-encoded binary content.</summary>
    [JsonPropertyName("blob")]
    public string? Blob { get; set; }

    /// <summary>MIME type of the content.</summary>
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Text content (e.g. HTML).</summary>
    [JsonPropertyName("text")]
    public string? Text { get; set; }

    /// <summary>The resource URI.</summary>
    [JsonPropertyName("uri")]
    public string Uri { get; set; } = string.Empty;
}

/// <summary>Resource contents returned by the MCP server.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourcesReadResult
{
    /// <summary>Resource contents returned by the server.</summary>
    [JsonPropertyName("contents")]
    public IList<McpResourceContent> Contents { get => field ??= []; set; }
}

/// <summary>MCP server and resource URI to fetch.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpResourcesReadRequest
{
    /// <summary>Name of the MCP server hosting the resource.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Resource URI.</summary>
    [JsonPropertyName("uri")]
    public string Uri { get; set; } = string.Empty;
}

/// <summary>Standard MCP resource annotations plus preserved non-standard annotation fields.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourceAnnotations
{
    /// <summary>Server-provided non-standard annotation fields preserved from the MCP response.</summary>
    [JsonPropertyName("additionalProperties")]
    public IDictionary<string, JsonElement>? AdditionalProperties { get; set; }

    /// <summary>Intended audience roles for this resource.</summary>
    [JsonPropertyName("audience")]
    public IList<string>? Audience { get; set; }

    /// <summary>Last-modified timestamp hint.</summary>
    [JsonPropertyName("lastModified")]
    public string? LastModified { get; set; }

    /// <summary>Priority hint for model/client use.</summary>
    [JsonPropertyName("priority")]
    public double? Priority { get; set; }
}

/// <summary>A resource icon descriptor plus preserved non-standard icon fields.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourceIcon
{
    /// <summary>Server-provided non-standard icon fields preserved from the MCP response.</summary>
    [JsonPropertyName("additionalProperties")]
    public IDictionary<string, JsonElement>? AdditionalProperties { get; set; }

    /// <summary>Icon MIME type, when known.</summary>
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Icon sizes hint.</summary>
    [JsonPropertyName("sizes")]
    public string? Sizes { get; set; }

    /// <summary>Icon URI.</summary>
    [JsonPropertyName("src")]
    public string Src { get; set; } = string.Empty;

    /// <summary>Theme hint for this icon.</summary>
    [JsonPropertyName("theme")]
    public string? Theme { get; set; }
}

/// <summary>An MCP resource descriptor (spec `Resource`): URI, name, and optional title, description, MIME type, size, icons, annotations, and metadata. Server-provided fields outside the standard descriptor shape are exposed under `additionalProperties`.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResource
{
    /// <summary>Resource-level metadata.</summary>
    [JsonPropertyName("_meta")]
    public IDictionary<string, JsonElement>? Meta { get; set; }

    /// <summary>Server-provided non-standard descriptor fields preserved from the MCP response.</summary>
    [JsonPropertyName("additionalProperties")]
    public IDictionary<string, JsonElement>? AdditionalProperties { get; set; }

    /// <summary>Model/client annotations associated with this resource.</summary>
    [JsonPropertyName("annotations")]
    public McpResourceAnnotations? Annotations { get; set; }

    /// <summary>Optional description of what this resource represents.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Icons associated with this resource.</summary>
    [JsonPropertyName("icons")]
    public IList<McpResourceIcon>? Icons { get; set; }

    /// <summary>MIME type of the resource, if known.</summary>
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>The programmatic name of the resource.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Resource size in bytes, when known.</summary>
    [JsonPropertyName("size")]
    public long? Size { get; set; }

    /// <summary>Optional human-readable display title.</summary>
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>The resource URI (e.g. ui://... or file:///...).</summary>
    [JsonPropertyName("uri")]
    public string Uri { get; set; } = string.Empty;
}

/// <summary>One page of resources advertised by the named MCP server.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourcesListResult
{
    /// <summary>Opaque cursor for the next page, if the server has more resources.</summary>
    [JsonPropertyName("nextCursor")]
    public string? NextCursor { get; set; }

    /// <summary>Resources advertised by the server (proxied MCP `resources/list`).</summary>
    [JsonPropertyName("resources")]
    public IList<McpResource> Resources { get => field ??= []; set; }
}

/// <summary>MCP server whose resources to enumerate.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpResourcesListRequest
{
    /// <summary>Opaque MCP pagination cursor from a prior `nextCursor` value.</summary>
    [JsonPropertyName("cursor")]
    public string? Cursor { get; set; }

    /// <summary>Name of the MCP server whose resources to enumerate.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>An MCP resource template descriptor (spec `ResourceTemplate`): an RFC 6570 URI template, name, and optional title, description, MIME type, icons, annotations, and metadata. Server-provided fields outside the standard descriptor shape are exposed under `additionalProperties`.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourceTemplate
{
    /// <summary>Resource-template-level metadata.</summary>
    [JsonPropertyName("_meta")]
    public IDictionary<string, JsonElement>? Meta { get; set; }

    /// <summary>Server-provided non-standard descriptor fields preserved from the MCP response.</summary>
    [JsonPropertyName("additionalProperties")]
    public IDictionary<string, JsonElement>? AdditionalProperties { get; set; }

    /// <summary>Model/client annotations associated with this template.</summary>
    [JsonPropertyName("annotations")]
    public McpResourceAnnotations? Annotations { get; set; }

    /// <summary>Optional description of what this template is for.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Icons associated with resources matching this template.</summary>
    [JsonPropertyName("icons")]
    public IList<McpResourceIcon>? Icons { get; set; }

    /// <summary>MIME type for resources matching this template, if uniform.</summary>
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>The programmatic name of the resource template.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Optional human-readable display title.</summary>
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>An RFC 6570 URI template for constructing resource URIs.</summary>
    [JsonPropertyName("uriTemplate")]
    public string UriTemplate { get; set; } = string.Empty;
}

/// <summary>One page of resource templates advertised by the named MCP server.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourcesListTemplatesResult
{
    /// <summary>Opaque cursor for the next page, if the server has more resource templates.</summary>
    [JsonPropertyName("nextCursor")]
    public string? NextCursor { get; set; }

    /// <summary>Resource templates advertised by the server (proxied MCP `resources/templates/list`).</summary>
    [JsonPropertyName("resourceTemplates")]
    public IList<McpResourceTemplate> ResourceTemplates { get => field ??= []; set; }
}

/// <summary>MCP server whose resource templates to enumerate.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class McpResourcesListTemplatesRequest
{
    /// <summary>Opaque MCP pagination cursor from a prior `nextCursor` value.</summary>
    [JsonPropertyName("cursor")]
    public string? Cursor { get; set; }

    /// <summary>Name of the MCP server whose resource templates to enumerate.</summary>
    [RegularExpression("^[^\\x00-\\x1f/\\x7f-\\x9f}]+(?:\\/[^\\x00-\\x1f/\\x7f-\\x9f}]+)*$")]
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("serverName")]
    public string ServerName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Session plugin metadata, with name, marketplace, optional version, and enabled state.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class Plugin
{
    /// <summary>Whether the plugin is currently enabled.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Marketplace the plugin came from.</summary>
    [JsonPropertyName("marketplace")]
    public string Marketplace { get; set; } = string.Empty;

    /// <summary>Plugin name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Installed version.</summary>
    [JsonPropertyName("version")]
    public string? Version { get; set; }
}

/// <summary>Plugins installed for the session, with their enabled state and version metadata.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PluginList
{
    /// <summary>Installed plugins.</summary>
    [JsonPropertyName("plugins")]
    public IList<Plugin> Plugins { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionPluginsListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>RPC data type for SessionPluginsReload operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionPluginsReloadRequest
{
    /// <summary>When true, skip repo-level hooks during the hook reload. Use before folder trust is confirmed; load them post-trust via `sessions.loadDeferredRepoHooks`.</summary>
    [JsonPropertyName("deferRepoHooks")]
    public bool? DeferRepoHooks { get; set; }

    /// <summary>Re-run custom-agent discovery after refreshing plugins. Defaults to true.</summary>
    [JsonPropertyName("reloadCustomAgents")]
    public bool? ReloadCustomAgents { get; set; }

    /// <summary>Re-discover and relaunch subprocess extensions (including plugin-shipped extensions) after refreshing plugins. Defaults to true. Has no effect when the session has no active extension controller (e.g. extensions were not requested for the session).</summary>
    [JsonPropertyName("reloadExtensions")]
    public bool? ReloadExtensions { get; set; }

    /// <summary>Re-load user, plugin, and (subject to `deferRepoHooks`) repo hooks. Defaults to true. Has no effect when the host has not registered a hook reloader (e.g. remote sessions).</summary>
    [JsonPropertyName("reloadHooks")]
    public bool? ReloadHooks { get; set; }

    /// <summary>Reload MCP server connections after refreshing plugins. Defaults to true.</summary>
    [JsonPropertyName("reloadMcp")]
    public bool? ReloadMcp { get; set; }
}

/// <summary>RPC data type for SessionPluginsReloadRequestWithSession operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionPluginsReloadRequestWithSession
{
    /// <summary>When true, skip repo-level hooks during the hook reload. Use before folder trust is confirmed; load them post-trust via `sessions.loadDeferredRepoHooks`.</summary>
    [JsonPropertyName("deferRepoHooks")]
    public bool? DeferRepoHooks { get; set; }

    /// <summary>Re-run custom-agent discovery after refreshing plugins. Defaults to true.</summary>
    [JsonPropertyName("reloadCustomAgents")]
    public bool? ReloadCustomAgents { get; set; }

    /// <summary>Re-discover and relaunch subprocess extensions (including plugin-shipped extensions) after refreshing plugins. Defaults to true. Has no effect when the session has no active extension controller (e.g. extensions were not requested for the session).</summary>
    [JsonPropertyName("reloadExtensions")]
    public bool? ReloadExtensions { get; set; }

    /// <summary>Re-load user, plugin, and (subject to `deferRepoHooks`) repo hooks. Defaults to true. Has no effect when the host has not registered a hook reloader (e.g. remote sessions).</summary>
    [JsonPropertyName("reloadHooks")]
    public bool? ReloadHooks { get; set; }

    /// <summary>Reload MCP server connections after refreshing plugins. Defaults to true.</summary>
    [JsonPropertyName("reloadMcp")]
    public bool? ReloadMcp { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Short-lived, rotating credential the caller must send on every request, in addition to `apiKey` if one is present. Omitted when the endpoint does not require one.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderSessionToken
{
    /// <summary>When the token expires, if known. Callers should refresh by calling `getEndpoint` again before this time, or reactively on any 401/403 response from `baseUrl`.</summary>
    [JsonPropertyName("expiresAt")]
    public DateTimeOffset? ExpiresAt { get; set; }

    /// <summary>HTTP header name the token must be sent under.</summary>
    [JsonPropertyName("header")]
    public string Header { get; set; } = string.Empty;

    /// <summary>The model the token is bound to, when applicable. When set, the token is only valid for requests against this model.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>The short-lived token value.</summary>
    [JsonPropertyName("token")]
    public string Token { get; set; } = string.Empty;
}

/// <summary>A snapshot of the provider endpoint the session is currently configured to talk to.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderEndpoint
{
    /// <summary>A credential the caller should use with this endpoint. Omitted only when the endpoint accepts unauthenticated requests.</summary>
    [JsonPropertyName("apiKey")]
    public string? ApiKey { get; set; }

    /// <summary>Base URL to pass to the LLM client library.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("baseUrl")]
    public string BaseUrl { get; set; } = string.Empty;

    /// <summary>HTTP headers the caller must include on every outbound request.</summary>
    [JsonPropertyName("headers")]
    public IDictionary<string, string> Headers { get => field ??= new Dictionary<string, string>(); set; }

    /// <summary>Short-lived, rotating credential the caller must send on every request, in addition to `apiKey` if one is present. Omitted when the endpoint does not require one.</summary>
    [JsonPropertyName("sessionToken")]
    public ProviderSessionToken? SessionToken { get; set; }

    /// <summary>Transport to be used for provider requests.</summary>
    [JsonPropertyName("transport")]
    public ProviderEndpointTransport? Transport { get; set; }

    /// <summary>Provider family. Matches the `type` field of a BYOK provider config.</summary>
    [JsonPropertyName("type")]
    public ProviderEndpointType Type { get; set; }

    /// <summary>Wire API to be used, when required for the provider type.</summary>
    [JsonPropertyName("wireApi")]
    public ProviderEndpointWireApi? WireApi { get; set; }
}

/// <summary>RPC data type for SessionProviderGetEndpoint operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionProviderGetEndpointRequest
{
    /// <summary>Model identifier the caller intends to use against the returned endpoint. Used to pick the correct wire shape. Omit to use whichever model the session is currently using.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }
}

/// <summary>RPC data type for SessionProviderGetEndpointRequestWithSession operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionProviderGetEndpointRequestWithSession
{
    /// <summary>Model identifier the caller intends to use against the returned endpoint. Used to pick the correct wire shape. Omit to use whichever model the session is currently using.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The selectable model entries synthesized for the models added by this call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderAddResult
{
    /// <summary>Synthesized selectable model entries for the newly added BYOK models, each under its provider-qualified selection id (`provider/id`). Empty when only providers were added.</summary>
    [JsonPropertyName("models")]
    public IList<JsonElement> Models { get => field ??= []; set; }
}

/// <summary>A BYOK model definition referencing a named provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderModelConfig
{
    /// <summary>Optional capability overrides (vision, tool_calls, reasoning, etc.).</summary>
    [JsonPropertyName("capabilities")]
    public ModelCapabilitiesOverride? Capabilities { get; set; }

    /// <summary>Provider-local model id, unique within its provider. The session-wide selection id (shown in the model list and passed to switchTo) is the provider-qualified `provider/id`.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Maximum context window tokens for the model.</summary>
    [JsonPropertyName("maxContextWindowTokens")]
    public double? MaxContextWindowTokens { get; set; }

    /// <summary>Maximum output tokens for the model.</summary>
    [JsonPropertyName("maxOutputTokens")]
    public double? MaxOutputTokens { get; set; }

    /// <summary>Maximum prompt/input tokens for the model.</summary>
    [JsonPropertyName("maxPromptTokens")]
    public double? MaxPromptTokens { get; set; }

    /// <summary>Well-known base model id used for behavior/capability/config lookup. Defaults to `id`.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }

    /// <summary>Display name for model pickers. Defaults to the provider-qualified selection id (`provider/id`).</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Name of the configured provider that serves this model.</summary>
    [JsonPropertyName("provider")]
    public string Provider { get; set; } = string.Empty;

    /// <summary>The model name sent to the provider API for inference. Defaults to `id`.</summary>
    [JsonPropertyName("wireModel")]
    public string? WireModel { get; set; }
}

/// <summary>Azure-specific provider options.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderConfigAzure
{
    /// <summary>API version. When set, uses the versioned deployment route. When omitted, uses the GA versionless v1 route.</summary>
    [JsonPropertyName("apiVersion")]
    public string? ApiVersion { get; set; }
}

/// <summary>External SDK input for a named custom model provider. Ingested by the native protocol boundary before host dispatch.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class NamedProviderConfig
{
    /// <summary>Static API key used to authenticate provider requests.</summary>
    [JsonPropertyName("apiKey")]
    public string? ApiKey { get; set; }

    /// <summary>Azure authentication configuration for the provider.</summary>
    [JsonPropertyName("azure")]
    public ProviderConfigAzure? Azure { get; set; }

    /// <summary>Base URL for provider API requests.</summary>
    [JsonPropertyName("baseUrl")]
    public string BaseUrl { get; set; } = string.Empty;

    /// <summary>Static bearer token used to authenticate provider requests.</summary>
    [JsonPropertyName("bearerToken")]
    public string? BearerToken { get; set; }

    /// <summary>Whether the host supplies bearer tokens dynamically.</summary>
    [JsonPropertyName("hasBearerTokenProvider")]
    public bool? HasBearerTokenProvider { get; set; }

    /// <summary>Additional HTTP headers included with provider requests.</summary>
    [JsonPropertyName("headers")]
    public IDictionary<string, string>? Headers { get; set; }

    /// <summary>Unique provider name used to qualify model selection IDs.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Transport used to communicate with the provider.</summary>
    [JsonPropertyName("transport")]
    public ProviderConfigTransport? Transport { get; set; }

    /// <summary>Provider protocol family.</summary>
    [JsonPropertyName("type")]
    public ProviderConfigType? Type { get; set; }

    /// <summary>Wire API used to communicate with the provider.</summary>
    [JsonPropertyName("wireApi")]
    public ProviderConfigWireApi? WireApi { get; set; }
}

/// <summary>BYOK providers and/or models to add to the session's registry at runtime. Both fields are optional; provide providers, models, or both.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ProviderAddRequest
{
    /// <summary>BYOK model definitions to register. Each must reference a provider that is already registered or included in this same call. Selection ids (`provider/id`) must be unique across the registry.</summary>
    [JsonPropertyName("models")]
    public IList<ProviderModelConfig>? Models { get; set; }

    /// <summary>Named BYOK provider connections to register, additive to any providers already in the registry. Each name must be unique across the registry and must not contain '/'.</summary>
    [JsonPropertyName("providers")]
    public IList<NamedProviderConfig>? Providers { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the session options patch was applied successfully.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionUpdateOptionsResult
{
    /// <summary>Number of hooks loaded from installed plugins, returned when installedPlugins is updated.</summary>
    [JsonPropertyName("pluginHookCount")]
    public long? PluginHookCount { get; set; }

    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Source descriptor for a `session.options.update` content-exclusion rule, with source name and type.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class OptionsUpdateAdditionalContentExclusionPolicyRuleSource
{
    /// <summary>Name of the policy source.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Type of the policy source.</summary>
    [JsonPropertyName("type")]
    public string Type { get; set; } = string.Empty;
}

/// <summary>Single content-exclusion rule supplied to `session.options.update`, with paths, match conditions, and source.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class OptionsUpdateAdditionalContentExclusionPolicyRule
{
    /// <summary>Conditions of which at least one must match.</summary>
    [JsonPropertyName("ifAnyMatch")]
    public IList<string>? IfAnyMatch { get; set; }

    /// <summary>Conditions none of which may match.</summary>
    [JsonPropertyName("ifNoneMatch")]
    public IList<string>? IfNoneMatch { get; set; }

    /// <summary>Path patterns covered by this rule.</summary>
    [JsonPropertyName("paths")]
    public IList<string> Paths { get => field ??= []; set; }

    /// <summary>Source descriptor for a `session.options.update` content-exclusion rule, with source name and type.</summary>
    [JsonPropertyName("source")]
    public OptionsUpdateAdditionalContentExclusionPolicyRuleSource Source { get => field ??= new(); set; }
}

/// <summary>Content-exclusion policy supplied to `session.options.update`, with rules, last-updated data, and scope.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class OptionsUpdateAdditionalContentExclusionPolicy
{
    /// <summary>Opaque policy update timestamp supplied by the host.</summary>
    [JsonPropertyName("last_updated_at")]
    public JsonElement LastUpdatedAt { get; set; }

    /// <summary>Content-exclusion rules to apply.</summary>
    [JsonPropertyName("rules")]
    public IList<OptionsUpdateAdditionalContentExclusionPolicyRule> Rules { get => field ??= []; set; }

    /// <summary>Allowed values for the `OptionsUpdateAdditionalContentExclusionPolicyScope` enumeration.</summary>
    [JsonPropertyName("scope")]
    public OptionsUpdateAdditionalContentExclusionPolicyScope Scope { get; set; }
}

/// <summary>Options scoped to the built-in CAPI (Copilot API) provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CapiSessionOptions
{
    /// <summary>Routing preference for sessions whose model is `auto`. On create or cold resume, this establishes the preference sent as `tier` on CAPI `/auto` requests; when omitted on cold resume, the runtime restores the last committed preference. On resident resume, a different value requests a safe switch after resume succeeds and cannot change an in-flight turn. Successful switches are persisted for later cold resume. When no preference is supplied or restored, CAPI default routing is used. `fast` is an integrator-only latency preset, not a first-party GitHub Copilot product preference.</summary>
    [JsonPropertyName("autoTier")]
    public AutoTier? AutoTier { get; set; }

    /// <summary>Whether to use WebSocket transport for the CAPI Responses API. Enabled by default when the model advertises `ws:/responses` support; set to `false` to force the HTTP Responses transport in environments where WebSockets are blocked (e.g. behind a proxy). Setting this to `false` is equivalent to the `COPILOT_CLI_DISABLE_WEBSOCKET_RESPONSES` environment variable.</summary>
    [JsonPropertyName("enableWebSocketResponses")]
    public bool? EnableWebSocketResponses { get; set; }
}

/// <summary>Installed plugin record for a session, with marketplace, version, install time, enabled state, cache path, and source.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionInstalledPlugin
{
    /// <summary>Path where the plugin is cached locally.</summary>
    [JsonPropertyName("cache_path")]
    public string? CachePath { get; set; }

    /// <summary>Whether the plugin is currently enabled.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Installation timestamp (ISO-8601).</summary>
    [JsonPropertyName("installed_at")]
    public string InstalledAt { get; set; } = string.Empty;

    /// <summary>Absolute path of the marketplace directory a live plugin was resolved from. Present only on live, never-persisted records — those synthesized at session start for a directory/local marketplace, whose cache_path points at the real plugin directory on disk rather than a copy under the installed-plugins cache. Its presence is what marks a record as live, and no record carrying it is ever written to the persisted installedPlugins key.</summary>
    [JsonPropertyName("installed_from")]
    public string? InstalledFrom { get; set; }

    /// <summary>Marketplace the plugin came from (empty string for direct repo installs).</summary>
    [JsonPropertyName("marketplace")]
    public string Marketplace { get; set; } = string.Empty;

    /// <summary>Plugin name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Source descriptor for direct repo installs (when marketplace is empty).</summary>
    [JsonPropertyName("source")]
    public JsonElement? Source { get; set; }

    /// <summary>Per-plugin source fingerprint (a SHA-256 hash of the plugin's catalog source spec plus its resolved source subtree — NOT a Git commit SHA) captured at marketplace install/update time. Auto-update compares it against the freshly recomputed fingerprint to detect a content change that does not bump the version. Absent for pre-existing installs and for direct (non-marketplace) installs.</summary>
    [JsonPropertyName("source_sha")]
    public string? SourceSha { get; set; }

    /// <summary>Installed version, if known.</summary>
    [JsonPropertyName("version")]
    public string? Version { get; set; }
}

/// <summary>Custom model-provider configuration (BYOK).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderConfig
{
    /// <summary>API key. Optional for local providers like Ollama.</summary>
    [JsonPropertyName("apiKey")]
    public string? ApiKey { get; set; }

    /// <summary>Azure-specific provider options.</summary>
    [JsonPropertyName("azure")]
    public ProviderConfigAzure? Azure { get; set; }

    /// <summary>API endpoint URL.</summary>
    [JsonPropertyName("baseUrl")]
    public string BaseUrl { get; set; } = string.Empty;

    /// <summary>Bearer token for authentication. Sets the Authorization header directly. Takes precedence over apiKey when both are set.</summary>
    [JsonPropertyName("bearerToken")]
    public string? BearerToken { get; set; }

    /// <summary>When true, the SDK client supplies bearer tokens on demand: the runtime calls the client-session `providerToken.getToken` callback before each request and applies the returned token as an `Authorization: Bearer &lt;token&gt;` header. This is the bearer/OAuth scheme used by Azure AD / managed-identity tokens and provider OAuth access tokens (including Anthropic's), not a provider-specific API-key header such as Anthropic's `x-api-key`. The token-acquiring function itself stays on the SDK side and is never serialized; only this flag crosses the wire. When set alongside `apiKey`/`bearerToken`, the callback takes precedence: the runtime applies the token returned by `providerToken.getToken` as the `Authorization: Bearer` header for each request and does not send the static credential.</summary>
    [JsonPropertyName("hasBearerTokenProvider")]
    public bool? HasBearerTokenProvider { get; set; }

    /// <summary>Custom HTTP headers to include in all outbound requests to the provider.</summary>
    [JsonPropertyName("headers")]
    public IDictionary<string, string>? Headers { get; set; }

    /// <summary>Maximum context window tokens for the model.</summary>
    [JsonPropertyName("maxContextWindowTokens")]
    public double? MaxContextWindowTokens { get; set; }

    /// <summary>Maximum output tokens for the model.</summary>
    [JsonPropertyName("maxOutputTokens")]
    public double? MaxOutputTokens { get; set; }

    /// <summary>Maximum prompt/input tokens for the model.</summary>
    [JsonPropertyName("maxPromptTokens")]
    public double? MaxPromptTokens { get; set; }

    /// <summary>Overrides for model capabilities when they cannot be inferred from modelId.</summary>
    [JsonPropertyName("modelCapabilities")]
    public ModelCapabilitiesOverride? ModelCapabilities { get; set; }

    /// <summary>Well-known model ID used for capability lookup. When set, agent behavior config and token limits are inferred from this model.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }

    /// <summary>Provider name used for model and telemetry attribution.</summary>
    [JsonPropertyName("providerName")]
    public string? ProviderName { get; set; }

    /// <summary>Provider transport. Defaults to "http".</summary>
    [JsonPropertyName("transport")]
    public ProviderConfigTransport? Transport { get; set; }

    /// <summary>Provider type. Defaults to "openai" for generic OpenAI-compatible APIs.</summary>
    [JsonPropertyName("type")]
    public ProviderConfigType? Type { get; set; }

    /// <summary>Wire API format (openai/azure only). Defaults to "completions".</summary>
    [JsonPropertyName("wireApi")]
    public ProviderConfigWireApi? WireApi { get; set; }

    /// <summary>The model identifier sent to the provider API for inference (the "wire" model), as opposed to modelId which is the well-known base.</summary>
    [JsonPropertyName("wireModel")]
    public string? WireModel { get; set; }
}

/// <summary>Credential-injection capability flags applied while the sandbox is enabled. For the same capability independent of sandboxing, and matched to the credential's GitHub host, see `shell.credentials`; the two are additive.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigAuth
{
    /// <summary>Whether to export `GH_TOKEN` so the `gh` CLI authenticates inside the sandbox without the OS keyring the sandbox blocks. Default: false (opt-in).</summary>
    [JsonPropertyName("gh")]
    public bool? Gh { get; set; }

    /// <summary>Whether to inject git credentials as an `http.&lt;url&gt;.extraheader` so authenticated HTTPS git works inside the sandbox without the shell-based credential helper the sandbox blocks. github.com is served by the Copilot token; every other forge (Azure DevOps, GitHub Enterprise Server, GitLab, ...) by a credential the host resolves from the user's own helper before the sandbox is applied. Default: false (opt-in).</summary>
    [JsonPropertyName("git")]
    public bool? Git { get; set; }
}

/// <summary>macOS seatbelt experimental options.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigUserPolicyExperimentalSeatbelt
{
    /// <summary>Whether the macOS seatbelt profile may access the keychain.</summary>
    [JsonPropertyName("keychainAccess")]
    public bool? KeychainAccess { get; set; }
}

/// <summary>Platform-specific experimental policy fields.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigUserPolicyExperimental
{
    /// <summary>macOS seatbelt experimental options.</summary>
    [JsonPropertyName("seatbelt")]
    public SandboxConfigUserPolicyExperimentalSeatbelt? Seatbelt { get; set; }
}

/// <summary>Filesystem rules to merge into the base policy.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigUserPolicyFilesystem
{
    /// <summary>Whether to clear the policy when the session exits.</summary>
    [JsonPropertyName("clearPolicyOnExit")]
    public bool? ClearPolicyOnExit { get; set; }

    /// <summary>Paths explicitly denied.</summary>
    [JsonPropertyName("deniedPaths")]
    public IList<string>? DeniedPaths { get; set; }

    /// <summary>Paths granted read-only access.</summary>
    [JsonPropertyName("readonlyPaths")]
    public IList<string>? ReadonlyPaths { get; set; }

    /// <summary>Paths granted read/write access.</summary>
    [JsonPropertyName("readwritePaths")]
    public IList<string>? ReadwritePaths { get; set; }
}

/// <summary>HTTP proxy configuration for sandboxed traffic.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigUserPolicyNetworkProxy
{
    /// <summary>Optional password for proxy authentication, combined with the URL at spawn time. The persisted value may be a literal password, a `${secret:…}` reference resolved from the OS keychain, or a `${VAR}`/`$VAR` environment reference; it is resolved just before the sandboxed process routes through the proxy. The /sandbox dialog stores a real password in the OS keychain and persists only a `${secret:…}` placeholder (never plaintext in settings.json); the field is masked in the dialog and redacted by /settings show.</summary>
    [JsonPropertyName("password")]
    public string? Password { get; set; }

    /// <summary>Proxy URL (e.g. http://proxy.example.com:8080). The port is optional and defaults to the scheme's standard port when omitted; an explicit port must be between 1 and 65535. Credentials must not be embedded here — a `user:pass@` authority is rejected; put them in the separate `username`/`password` fields. A credential-free http:// loopback proxy URL is routed through the localhost proxy automatically; loopback covers localhost and any *.localhost subdomain, the whole 127.0.0.0/8 range, ::1, and IPv4-mapped loopback (::ffff:127.0.0.1). An https:// URL, or one with a username/password set, is used as-is.</summary>
    [JsonPropertyName("url")]
    public string Url { get; set; } = string.Empty;

    /// <summary>Optional username for proxy authentication. Combined with the URL (and `password`) into `user:pass@host` when the sandboxed process routes through the proxy.</summary>
    [JsonPropertyName("username")]
    public string? Username { get; set; }
}

/// <summary>Network rules to merge into the base policy.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigUserPolicyNetwork
{
    /// <summary>Whether traffic to local/loopback addresses is allowed.</summary>
    [JsonPropertyName("allowLocalNetwork")]
    public bool? AllowLocalNetwork { get; set; }

    /// <summary>Whether outbound network traffic is allowed at all.</summary>
    [JsonPropertyName("allowOutbound")]
    public bool? AllowOutbound { get; set; }

    /// <summary>HTTP proxy for sandboxed process traffic. Linux restricts egress to the proxy endpoint, requires that endpoint to be reachable over IPv4 (the [::] dual-stack wildcard is accepted and routed through the IPv4 gateway), and does not support proxy credentials. macOS relies on applications honoring proxy environment variables. Windows also configures a per-AppContainer WinHTTP proxy, but enforcement depends on the application's networking stack. Configure supported credentials in the separate `username` and `password` fields. A credential-free http:// loopback URL uses the localhost proxy form, while an https:// or authenticated loopback URL uses the URL form.</summary>
    [JsonPropertyName("proxy")]
    public SandboxConfigUserPolicyNetworkProxy? Proxy { get; set; }
}

/// <summary>macOS seatbelt-specific options.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigUserPolicySeatbelt
{
    /// <summary>Whether the macOS seatbelt profile may access the keychain.</summary>
    [JsonPropertyName("keychainAccess")]
    public bool? KeychainAccess { get; set; }
}

/// <summary>User-managed sandbox policy fragment merged into the auto-discovered base policy.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfigUserPolicy
{
    /// <summary>Deprecated legacy location for `seatbelt`; read only when the top-level `seatbelt` is absent.</summary>
    [JsonPropertyName("experimental")]
    public SandboxConfigUserPolicyExperimental? Experimental { get; set; }

    /// <summary>Filesystem rules to merge into the base policy.</summary>
    [JsonPropertyName("filesystem")]
    public SandboxConfigUserPolicyFilesystem? Filesystem { get; set; }

    /// <summary>Network rules to merge into the base policy.</summary>
    [JsonPropertyName("network")]
    public SandboxConfigUserPolicyNetwork? Network { get; set; }

    /// <summary>macOS seatbelt options to merge into the base policy.</summary>
    [JsonPropertyName("seatbelt")]
    public SandboxConfigUserPolicySeatbelt? Seatbelt { get; set; }
}

/// <summary>Resolved sandbox configuration.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxConfig
{
    /// <summary>Whether to auto-add the current working directory to readwritePaths. Default: true.</summary>
    [JsonPropertyName("addCurrentWorkingDirectory")]
    public bool? AddCurrentWorkingDirectory { get; set; }

    /// <summary>Whether the agent may request that an individual command run outside the sandbox, which the host then approves or denies through the usual permission flow. A host capability flag rather than part of the policy: it is stripped from the effective spawn policy and only has an effect while `enabled` is true. Fail-closed, unlike the opt-out flags on this object: omitting it offers no bypass. Default: false (opt-in).</summary>
    [JsonPropertyName("allowBypass")]
    public bool? AllowBypass { get; set; }

    /// <summary>Whether to auto-grant read access to tool directories discovered on PATH and in toolchain environment variables (GOROOT, JAVA_HOME, VIRTUAL_ENV, and similar), and to common developer-tool caches, config, and toolchains. Writable grants cover scratch caches, the Unix GitHub CLI cache, and Cargo's registry, git store, and lock/tracker files. A relocated CARGO_HOME gets the same narrow split: registry and git are read-write; bin is read-only; the home root, config.toml, and credentials.toml stay ungranted. Set to false to disable every grant listed above; user-installed toolchains and caches then need explicit userPolicy.filesystem readonlyPaths and readwritePaths entries. The working directory (see addCurrentWorkingDirectory), temporary storage, session log paths, and system locations follow their own rules and stay granted. Default: true (enabled by default; set to false to opt out).</summary>
    [JsonPropertyName("allowDevToolAccess")]
    public bool? AllowDevToolAccess { get; set; }

    /// <summary>Credential-injection capability flags.</summary>
    [JsonPropertyName("auth")]
    public SandboxConfigAuth? Auth { get; set; }

    /// <summary>Whether sandboxing is enabled for the session.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>The `sandboxLspServers` counterpart of `managedMcpRoutingLocked`.</summary>
    [JsonInclude]
    [JsonPropertyName("managedLspRoutingLocked")]
    internal bool? ManagedLspRoutingLocked { get; set; }

    /// <summary>Set by the runtime when a managed policy forced `sandboxMcpServers` on and took the local opt-out away. Provenance rather than policy: it lets a sandbox startup failure point at the administrator instead of a setting the next managed merge would override, and it is ignored when comparing two configs for change. Only the managed merge may set it; a caller-supplied value is stripped.</summary>
    [JsonInclude]
    [JsonPropertyName("managedMcpRoutingLocked")]
    internal bool? ManagedMcpRoutingLocked { get; set; }

    /// <summary>Whether language servers the session launches are confined by the sandbox. Only an explicit `false` opts out. Ignored while `enabled` is false. Default: true (enabled by default; set to false to opt out).</summary>
    [JsonPropertyName("sandboxLspServers")]
    public bool? SandboxLspServers { get; set; }

    /// <summary>Whether MCP servers the session launches are confined by the sandbox. Only an explicit `false` opts out; doing so also lets remote-MCP egress leave the sandbox, so the flag and `enabled` are always read together. Ignored while `enabled` is false. Default: true (enabled by default; set to false to opt out).</summary>
    [JsonPropertyName("sandboxMcpServers")]
    public bool? SandboxMcpServers { get; set; }

    /// <summary>User-managed sandbox policy fragment merged into the auto-discovered base policy.</summary>
    [JsonPropertyName("userPolicy")]
    public SandboxConfigUserPolicy? UserPolicy { get; set; }
}

/// <summary>
/// Command-scoped GitHub credential injection for the shell commands an agent runs.
/// 
/// Each channel is opt-in and independent, and injection is scoped to the individual command
/// spawn: the credential is resolved from the session's *current* authentication at every spawn
/// and reaches only spawns whose script actually invokes `git` or `gh`. Because nothing is
/// retained between spawns, replacing the session credential (`session.gitHubAuth.setCredentials`)
/// changes what the next spawned command presents — which seeding a credential into the runtime
/// process's own environment cannot do, since a child's environment is fixed at `exec`.
/// 
/// The credential is matched to the host it authenticates to, so a github.com credential is never
/// presented to a GitHub Enterprise host and vice versa. Where a channel cannot express that
/// boundary it injects nothing rather than crossing it -- see `gh` below.
/// 
/// This is independent of `sandboxConfig`: it is a decision about which identity the agent
/// presents, not about what the agent may touch, and it works on every platform whether or not
/// an OS sandboxing backend is available. `sandboxConfig.auth` remains the sandbox-scoped
/// spelling and is additive with this one.
/// </summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ShellCredentials
{
    /// <summary>
    /// Whether to authenticate the agent's `gh` commands as the session's GitHub credential, by
    /// exporting `GH_TOKEN` to a spawn that runs `gh`. Any inherited `gh` credential is removed from
    /// spawns that do not, so the credential stays command-scoped.
    /// 
    /// Applies to a github.com credential only. `gh` picks its credential variable from the host a
    /// command targets rather than the one the credential belongs to, and the command can choose that
    /// target, so `GH_ENTERPRISE_TOKEN` would offer a single-tenant enterprise credential to every
    /// other enterprise host. A session whose credential is enterprise-scoped therefore runs `gh`
    /// unauthenticated; its `git` commands are unaffected, because `http.&lt;host&gt;.extraheader` is scoped
    /// to one host by construction. Default: false (opt-in).
    /// </summary>
    [JsonPropertyName("gh")]
    public bool? Gh { get; set; }

    /// <summary>
    /// Whether to authenticate the agent's `git` commands as the session's GitHub credential, by
    /// injecting an `http.&lt;host&gt;.extraheader` (plus `insteadOf` rewrites so SSH-spelled remotes for
    /// that host use the authenticated HTTPS transport). Applied only to a spawn that runs a
    /// remote-contacting `git` subcommand. Default: false (opt-in).
    /// </summary>
    [JsonPropertyName("git")]
    public bool? Git { get; set; }
}

/// <summary>A host-provided script sourced before each built-in shell command when its shell target matches the active shell.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ShellInitScript
{
    /// <summary>Path to the script to source.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Built-in shell that may source this script.</summary>
    [JsonPropertyName("shell")]
    public ShellInitScriptShell Shell { get; set; }
}

/// <summary>Per-session settings for built-in shell tools.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ShellOptions
{
    /// <summary>Command-scoped GitHub credential injection for shell commands.</summary>
    [JsonPropertyName("credentials")]
    public ShellCredentials? Credentials { get; set; }

    /// <summary>Controls automatic non-interactive profile loading where supported. Explicit initScripts are unaffected.</summary>
    [JsonPropertyName("initProfile")]
    public ShellInitProfile? InitProfile { get; set; }

    /// <summary>
    /// Ordered host-provided script paths sourced before each built-in shell command when the
    /// entry's shell target matches the active shell. Use these for rc files, environment setup scripts,
    /// or other custom scripts. A script that returns a nonzero status is reported, and later scripts
    /// and the user command continue while the shell remains running. Because scripts are sourced into
    /// the command shell, `exit`, `exec`, failures under `set -e`, or other shell-terminating behavior
    /// can prevent continuation. Script standard output is preserved; Bash script stderr is discarded,
    /// PowerShell exception messages are replaced, and runtime-generated failure notices omit
    /// configured script paths. When sandboxing is enabled, each script must already be readable under
    /// the active sandbox filesystem policy. Pass an empty array to clear the list.
    /// </summary>
    [JsonPropertyName("initScripts")]
    public IList<ShellInitScript>? InitScripts { get; set; }

    /// <summary>
    /// Flags passed to the active built-in shell process on startup, replacing its default flags.
    /// When omitted, the built-in Bash shell uses `--norc --noprofile`,
    /// and the built-in PowerShell shell uses `-NoProfile -NoLogo`.
    /// </summary>
    [JsonPropertyName("processFlags")]
    public IList<string>? ProcessFlags { get; set; }
}

/// <summary>Patch of mutable session options to apply to the running session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionUpdateOptionsParams
{
    /// <summary>Additional content-exclusion policies to merge into the session's policy set.</summary>
    [Experimental(Diagnostics.Experimental)]
    [JsonPropertyName("additionalContentExclusionPolicies")]
    public IList<OptionsUpdateAdditionalContentExclusionPolicy>? AdditionalContentExclusionPolicies { get; set; }

    /// <summary>Runtime context discriminator (e.g., `cli`, `actions`).</summary>
    [JsonPropertyName("agentContext")]
    public string? AgentContext { get; set; }

    /// <summary>Whether to include instructions from every MCP server in the system prompt instead of only allowlisted servers.</summary>
    [JsonPropertyName("allowAllMcpServerInstructions")]
    public bool? AllowAllMcpServerInstructions { get; set; }

    /// <summary>Whether to disable the `ask_user` tool (encourages autonomous behavior).</summary>
    [JsonPropertyName("askUserDisabled")]
    public bool? AskUserDisabled { get; set; }

    /// <summary>Allowlist of tool names available to this session.</summary>
    [JsonPropertyName("availableTools")]
    public IList<string>? AvailableTools { get; set; }

    /// <summary>Options scoped to the built-in CAPI (Copilot API) provider.</summary>
    [JsonPropertyName("capi")]
    public CapiSessionOptions? Capi { get; set; }

    /// <summary>Identifier of the client driving the session.</summary>
    [JsonPropertyName("clientName")]
    public string? ClientName { get; set; }

    /// <summary>Whether to include the `Co-authored-by` trailer in commit messages.</summary>
    [JsonPropertyName("coauthorEnabled")]
    public bool? CoauthorEnabled { get; set; }

    /// <summary>Context tier for models with tiered pricing. The session uses this to derive effective `modelCapabilitiesOverrides` so compaction, truncation, token display, and request limits honor the selected tier.</summary>
    [JsonPropertyName("contextTier")]
    public OptionsUpdateContextTier? ContextTier { get; set; }

    /// <summary>Whether to allow auto-mode continuation across turns.</summary>
    [JsonPropertyName("continueOnAutoMode")]
    public bool? ContinueOnAutoMode { get; set; }

    /// <summary>Override URL for the Copilot API endpoint.</summary>
    [JsonPropertyName("copilotUrl")]
    public string? CopilotUrl { get; set; }

    /// <summary>Whether to default custom agents to local-only execution.</summary>
    [JsonPropertyName("customAgentsLocalOnly")]
    public bool? CustomAgentsLocalOnly { get; set; }

    /// <summary>Instruction source IDs to exclude from the system prompt.</summary>
    [JsonPropertyName("disabledInstructionSources")]
    public IList<string>? DisabledInstructionSources { get; set; }

    /// <summary>Skill IDs that should be excluded from this session.</summary>
    [JsonPropertyName("disabledSkills")]
    public IList<string>? DisabledSkills { get; set; }

    /// <summary>Whether to enable loading of `.github/hooks/` filesystem hooks. Separate from the SDK callback hook mechanism.</summary>
    [JsonPropertyName("enableFileHooks")]
    public bool? EnableFileHooks { get; set; }

    /// <summary>Whether to enable host git operations (context resolution, child repo scanning, git info in system prompt).</summary>
    [JsonPropertyName("enableHostGitOperations")]
    public bool? EnableHostGitOperations { get; set; }

    /// <summary>Whether to discover custom instructions on demand after successful file views (AGENTS.md / CLAUDE.md / .github/copilot-instructions.md surfacing). Combined with `skipCustomInstructions`.</summary>
    [JsonPropertyName("enableOnDemandInstructionDiscovery")]
    public bool? EnableOnDemandInstructionDiscovery { get; set; }

    /// <summary>Whether to surface reasoning-summary events from the model.</summary>
    [JsonPropertyName("enableReasoningSummaries")]
    public bool? EnableReasoningSummaries { get; set; }

    /// <summary>Whether shell-script safety heuristics are enabled.</summary>
    [JsonPropertyName("enableScriptSafety")]
    public bool? EnableScriptSafety { get; set; }

    /// <summary>Whether to enable cross-session store writes and reads.</summary>
    [JsonPropertyName("enableSessionStore")]
    public bool? EnableSessionStore { get; set; }

    /// <summary>Whether skill loading is enabled. Explicit false disables every source, including a bound SDK provider; changing the value invalidates the loaded skill snapshot. When omitted, creation falls back to enableConfigDiscovery unless an SDK skill provider is registered.</summary>
    [JsonPropertyName("enableSkills")]
    public bool? EnableSkills { get; set; }

    /// <summary>Whether to stream model responses.</summary>
    [JsonPropertyName("enableStreaming")]
    public bool? EnableStreaming { get; set; }

    /// <summary>How env values are passed to MCP servers (`direct` inlines literal values; `indirect` resolves at launch).</summary>
    [JsonPropertyName("envValueMode")]
    public OptionsUpdateEnvValueMode? EnvValueMode { get; set; }

    /// <summary>Override directory for the session-events log. When unset, the runtime's default events log directory is used.</summary>
    [JsonPropertyName("eventsLogDirectory")]
    public string? EventsLogDirectory { get; set; }

    /// <summary>Whether subagent callback events should be forwarded into the session event log sink.</summary>
    [JsonPropertyName("eventsLogIncludesSubagents")]
    public bool? EventsLogIncludesSubagents { get; set; }

    /// <summary>Built-in subagent names to exclude from this session. Excluded built-ins are hidden from agent discovery and cannot be dispatched unless a custom agent with the same name is available.</summary>
    [JsonPropertyName("excludedBuiltinAgents")]
    public IList<string>? ExcludedBuiltinAgents { get; set; }

    /// <summary>Denylist of tool names for this session.</summary>
    [JsonPropertyName("excludedTools")]
    public IList<string>? ExcludedTools { get; set; }

    /// <summary>Map of feature-flag IDs to their boolean enabled state.</summary>
    [JsonPropertyName("featureFlags")]
    public IDictionary<string, bool>? FeatureFlags { get; set; }

    /// <summary>Built-in subagent names to include in this session. When specified, only these built-ins are available, subject to runtime availability and exclusions. Custom agents with the same name remain available. Set to null to remove the allowlist restriction.</summary>
    [JsonPropertyName("includedBuiltinAgents")]
    public IList<string>? IncludedBuiltinAgents { get; set; }

    /// <summary>Built-in skill names to include in this session. When specified, only these runtime-bundled skills are available. Skills from other sources with the same name remain available. Set to null to remove the allowlist restriction.</summary>
    [JsonPropertyName("includedBuiltinSkills")]
    public IList<string>? IncludedBuiltinSkills { get; set; }

    /// <summary>Full set of installed plugins for the session. Replaces the existing list; the runtime invalidates the skills cache only when the list materially changes.</summary>
    [JsonPropertyName("installedPlugins")]
    public IList<SessionInstalledPlugin>? InstalledPlugins { get; set; }

    /// <summary>Stable integration identifier used for analytics and rate-limit attribution.</summary>
    [JsonPropertyName("integrationId")]
    public string? IntegrationId { get; set; }

    /// <summary>Whether experimental capabilities are enabled.</summary>
    [JsonPropertyName("isExperimentalMode")]
    public bool? IsExperimentalMode { get; set; }

    /// <summary>Whether interactive shell sessions are logged.</summary>
    [JsonPropertyName("logInteractiveShells")]
    public bool? LogInteractiveShells { get; set; }

    /// <summary>Identifier sent to LSP-style integrations.</summary>
    [JsonPropertyName("lspClientName")]
    public string? LspClientName { get; set; }

    /// <summary>Whether to expose the `manage_schedule` tool to the agent. The runtime always owns the per-session schedule registry; this flag only controls tool exposure (typically gated to staff users).</summary>
    [JsonPropertyName("manageScheduleEnabled")]
    public bool? ManageScheduleEnabled { get; set; }

    /// <summary>Maximum decoded byte size of a single model-facing binary tool result (e.g. an image) persisted inline in session events and re-presented to the model on later turns / resume. Larger results are persisted as a metadata-only marker and shown to the model as a short text note. Defaults to 10 MB.</summary>
    [JsonPropertyName("maxInlineBinaryBytes")]
    public long? MaxInlineBinaryBytes { get; set; }

    /// <summary>The model ID to use for assistant turns.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Per-property model capability overrides for the selected model.</summary>
    [JsonPropertyName("modelCapabilitiesOverrides")]
    public ModelCapabilitiesOverride? ModelCapabilitiesOverrides { get; set; }

    /// <summary>Organization-level custom instructions to inject into the system prompt.</summary>
    [JsonPropertyName("organizationCustomInstructions")]
    public string? OrganizationCustomInstructions { get; set; }

    /// <summary>Custom model-provider configuration (BYOK).</summary>
    [JsonPropertyName("provider")]
    public ProviderConfig? Provider { get; set; }

    /// <summary>Reasoning effort for the selected model. CAPI values are model-defined and validated against the selected model; BYOK providers may define additional values. When omitted, no effort override is applied.</summary>
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Reasoning summary mode for supported model clients.</summary>
    [JsonPropertyName("reasoningSummary")]
    public OptionsUpdateReasoningSummary? ReasoningSummary { get; set; }

    /// <summary>Whether the session is running in an interactive UI.</summary>
    [JsonPropertyName("runningInInteractiveMode")]
    public bool? RunningInInteractiveMode { get; set; }

    /// <summary>Resolved sandbox configuration.</summary>
    [JsonPropertyName("sandboxConfig")]
    public SandboxConfig? SandboxConfig { get; set; }

    /// <summary>Origin of the sandbox choice. The runtime uses this only for internal telemetry provenance; managed policy is derived independently.</summary>
    [JsonInclude]
    [JsonPropertyName("sandboxConfigSource")]
    internal SandboxConfigSource? SandboxConfigSource { get; set; }

    /// <summary>Replaces the session's capability set with the given list. Use to enable or disable capabilities mid-session (e.g., remove `memory` for reproducible scripted runs). Omit the field to leave the existing capability set unchanged.</summary>
    [JsonPropertyName("sessionCapabilities")]
    public IList<SessionCapability>? SessionCapabilities { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional session limits. Pass null to clear the session limits.</summary>
    [JsonPropertyName("sessionLimits")]
    public SessionLimitsConfig? SessionLimits { get; set; }

    /// <summary>Per-session settings for built-in shell tools.</summary>
    [JsonPropertyName("shell")]
    public ShellOptions? Shell { get; set; }

    /// <summary>Use shell.initProfile instead. Shell init profile (`None` or `NonInteractive`).</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
#if NET5_0_OR_GREATER
    [Obsolete("This member is deprecated and will be removed in a future version.", DiagnosticId = "GHCP001")]
#endif
    [JsonPropertyName("shellInitProfile")]
    public string? ShellInitProfile { get; set; }

    /// <summary>PowerShell process flags applied to built-in and user-requested shell commands.</summary>
    [JsonPropertyName("shellProcessFlags")]
    public IList<string>? ShellProcessFlags { get; set; }

    /// <summary>Additional directories to search for skills.</summary>
    [JsonPropertyName("skillDirectories")]
    public IList<string>? SkillDirectories { get; set; }

    /// <summary>Whether to skip loading custom instruction sources.</summary>
    [JsonPropertyName("skipCustomInstructions")]
    public bool? SkipCustomInstructions { get; set; }

    /// <summary>Whether to skip embedding retrieval pipeline initialization and execution.</summary>
    [JsonPropertyName("skipEmbeddingRetrieval")]
    public bool? SkipEmbeddingRetrieval { get; set; }

    /// <summary>When true, the selected custom agent's prompt is not injected into the user message (skill context is still injected). Used by automation triggers where the agent prompt is already in the problem statement.</summary>
    [JsonPropertyName("suppressCustomAgentPrompt")]
    public bool? SuppressCustomAgentPrompt { get; set; }

    /// <summary>Controls how availableTools (allowlist) and excludedTools (denylist) combine when both are set.</summary>
    [JsonPropertyName("toolFilterPrecedence")]
    public OptionsUpdateToolFilterPrecedence? ToolFilterPrecedence { get; set; }

    /// <summary>Optional path for trajectory output.</summary>
    [JsonPropertyName("trajectoryFile")]
    public string? TrajectoryFile { get; set; }

    /// <summary>Output verbosity level for supported models.</summary>
    [JsonPropertyName("verbosity")]
    public Verbosity? Verbosity { get; set; }

    /// <summary>Absolute working-directory path for shell tools.</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Parameters for (re)loading the merged LSP configuration set.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class LspInitializeRequest
{
    /// <summary>Force re-initialization even when LSP configs were already loaded for the working directory.</summary>
    [JsonPropertyName("force")]
    public bool? Force { get; set; }

    /// <summary>Git root used as the boundary when traversing for project-level LSP configs (supports monorepos).</summary>
    [JsonPropertyName("gitRoot")]
    public string? GitRoot { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Working directory used to load project-level LSP configs. Defaults to the session working directory when omitted.</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Discovered extension metadata, including source-qualified ID, name, discovery source, status, and optional process ID.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class Extension
{
    /// <summary>Source-qualified ID (e.g., 'project:my-ext', 'user:auth-helper', 'plugin:my-plugin:my-ext').</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Extension name (directory name).</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Process ID if the extension is running.</summary>
    [JsonPropertyName("pid")]
    public long? Pid { get; set; }

    /// <summary>Discovery source: project (.github/extensions/), user (~/.copilot/extensions/), plugin (installed plugin), or session (session-state/&lt;id&gt;/extensions/).</summary>
    [JsonPropertyName("source")]
    public ExtensionSource Source { get; set; }

    /// <summary>Current status: running, disabled, failed, or starting.</summary>
    [JsonPropertyName("status")]
    public ExtensionStatus Status { get; set; }
}

/// <summary>Extensions discovered for the session, with their current status.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExtensionList
{
    /// <summary>Discovered extensions and their current status.</summary>
    [JsonPropertyName("extensions")]
    public IList<Extension> Extensions { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionExtensionsListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Source-qualified extension identifier to enable for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ExtensionsEnableRequest
{
    /// <summary>Source-qualified extension ID to enable.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Source-qualified extension identifier to disable for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ExtensionsDisableRequest
{
    /// <summary>Source-qualified extension ID to disable.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionExtensionsReloadRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Attachment union accepted by push input, covering files, directories, GitHub objects, blobs, snippets, and extension context.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PushAttachmentFile), "file")]
[JsonDerivedType(typeof(PushAttachmentDirectory), "directory")]
[JsonDerivedType(typeof(PushAttachmentSelection), "selection")]
[JsonDerivedType(typeof(PushAttachmentGitHubReference), "github_reference")]
[JsonDerivedType(typeof(PushAttachmentGitHubCommit), "github_commit")]
[JsonDerivedType(typeof(PushAttachmentGitHubRelease), "github_release")]
[JsonDerivedType(typeof(PushAttachmentGitHubActionsJob), "github_actions_job")]
[JsonDerivedType(typeof(PushAttachmentGitHubRepository), "github_repository")]
[JsonDerivedType(typeof(PushAttachmentGitHubFileDiff), "github_file_diff")]
[JsonDerivedType(typeof(PushAttachmentGitHubTreeComparison), "github_tree_comparison")]
[JsonDerivedType(typeof(PushAttachmentGitHubUrl), "github_url")]
[JsonDerivedType(typeof(PushAttachmentGitHubFile), "github_file")]
[JsonDerivedType(typeof(PushAttachmentGitHubSnippet), "github_snippet")]
[JsonDerivedType(typeof(PushAttachmentBlob), "blob")]
[JsonDerivedType(typeof(PushAttachmentExtensionContext), "extension_context")]
public partial class PushAttachment
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>Optional line range to scope the attachment to a specific section of the file.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PushAttachmentFileLineRange
{
    /// <summary>End line number (1-based, inclusive).</summary>
    [JsonPropertyName("end")]
    public long End { get; set; }

    /// <summary>Start line number (1-based).</summary>
    [JsonPropertyName("start")]
    public long Start { get; set; }
}

/// <summary>File attachment.</summary>
/// <remarks>The <c>file</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentFile : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "file";

    /// <summary>User-facing display name for the attachment.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Optional line range to scope the attachment to a specific section of the file.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("lineRange")]
    public PushAttachmentFileLineRange? LineRange { get; set; }

    /// <summary>Absolute file path.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }
}

/// <summary>Directory attachment.</summary>
/// <remarks>The <c>directory</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentDirectory : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "directory";

    /// <summary>User-facing display name for the attachment.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Absolute directory path.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }
}

/// <summary>End position of the selection.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PushAttachmentSelectionDetailsEnd
{
    /// <summary>End character offset within the line (0-based).</summary>
    [JsonPropertyName("character")]
    public long Character { get; set; }

    /// <summary>End line number (0-based).</summary>
    [JsonPropertyName("line")]
    public long Line { get; set; }
}

/// <summary>Start position of the selection.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PushAttachmentSelectionDetailsStart
{
    /// <summary>Start character offset within the line (0-based).</summary>
    [JsonPropertyName("character")]
    public long Character { get; set; }

    /// <summary>Start line number (0-based).</summary>
    [JsonPropertyName("line")]
    public long Line { get; set; }
}

/// <summary>Position range of the selection within the file.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PushAttachmentSelectionDetails
{
    /// <summary>End position of the selection.</summary>
    [JsonPropertyName("end")]
    public PushAttachmentSelectionDetailsEnd End { get => field ??= new(); set; }

    /// <summary>Start position of the selection.</summary>
    [JsonPropertyName("start")]
    public PushAttachmentSelectionDetailsStart Start { get => field ??= new(); set; }
}

/// <summary>Code selection attachment from an editor.</summary>
/// <remarks>The <c>selection</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentSelection : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "selection";

    /// <summary>User-facing display name for the selection.</summary>
    [JsonPropertyName("displayName")]
    public required string DisplayName { get; set; }

    /// <summary>Absolute path to the file containing the selection.</summary>
    [JsonPropertyName("filePath")]
    public required string FilePath { get; set; }

    /// <summary>Position range of the selection within the file.</summary>
    [JsonPropertyName("selection")]
    public required PushAttachmentSelectionDetails Selection { get; set; }

    /// <summary>The selected text content.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }
}

/// <summary>GitHub issue, pull request, or discussion reference.</summary>
/// <remarks>The <c>github_reference</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubReference : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_reference";

    /// <summary>Issue, pull request, or discussion number.</summary>
    [JsonPropertyName("number")]
    public required long Number { get; set; }

    /// <summary>Type of GitHub reference.</summary>
    [JsonPropertyName("referenceType")]
    public required PushAttachmentGitHubReferenceType ReferenceType { get; set; }

    /// <summary>Current state of the referenced item (e.g., open, closed, merged).</summary>
    [JsonPropertyName("state")]
    public required string State { get; set; }

    /// <summary>Title of the referenced item.</summary>
    [JsonPropertyName("title")]
    public required string Title { get; set; }

    /// <summary>URL to the referenced item on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a GitHub repository.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PushGitHubRepoRef
{
    /// <summary>Numeric GitHub repository id.</summary>
    [JsonPropertyName("id")]
    public long? Id { get; set; }

    /// <summary>Repository name (without owner).</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Repository owner login (user or organization).</summary>
    [JsonPropertyName("owner")]
    public string Owner { get; set; } = string.Empty;
}

/// <summary>Pointer to a GitHub commit.</summary>
/// <remarks>The <c>github_commit</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubCommit : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_commit";

    /// <summary>First line of the commit message.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Full commit SHA.</summary>
    [JsonPropertyName("oid")]
    public required string Oid { get; set; }

    /// <summary>Repository the commit belongs to.</summary>
    [JsonPropertyName("repo")]
    public required PushGitHubRepoRef Repo { get; set; }

    /// <summary>URL to the commit on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a GitHub release.</summary>
/// <remarks>The <c>github_release</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubRelease : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_release";

    /// <summary>Human-readable release name.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Repository the release belongs to.</summary>
    [JsonPropertyName("repo")]
    public required PushGitHubRepoRef Repo { get; set; }

    /// <summary>Git tag the release is anchored to.</summary>
    [JsonPropertyName("tagName")]
    public required string TagName { get; set; }

    /// <summary>URL to the release on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a GitHub Actions job.</summary>
/// <remarks>The <c>github_actions_job</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubActionsJob : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_actions_job";

    /// <summary>Terminal conclusion of the job when finished (e.g., success, failure, cancelled). Absent for in-progress jobs.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("conclusion")]
    public string? Conclusion { get; set; }

    /// <summary>Job id within the workflow run.</summary>
    [JsonPropertyName("jobId")]
    public required long JobId { get; set; }

    /// <summary>Display name of the job.</summary>
    [JsonPropertyName("jobName")]
    public required string JobName { get; set; }

    /// <summary>Repository the workflow run belongs to.</summary>
    [JsonPropertyName("repo")]
    public required PushGitHubRepoRef Repo { get; set; }

    /// <summary>URL to the job on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }

    /// <summary>Display name of the workflow the job ran in.</summary>
    [JsonPropertyName("workflowName")]
    public required string WorkflowName { get; set; }
}

/// <summary>Pointer to a GitHub repository.</summary>
/// <remarks>The <c>github_repository</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubRepository : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_repository";

    /// <summary>Short description of the repository.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Git ref this attachment is anchored at (branch, tag, or commit). When absent the default branch is implied.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("ref")]
    public string? Ref { get; set; }

    /// <summary>Repository pointer.</summary>
    [JsonPropertyName("repo")]
    public required PushGitHubRepoRef Repo { get; set; }

    /// <summary>URL to the repository on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>One side of a file diff (head or base).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PushAttachmentGitHubFileDiffSide
{
    /// <summary>Repository-relative path to the file.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Git ref (branch, tag, or commit SHA) the file is read at.</summary>
    [JsonPropertyName("ref")]
    public string Ref { get; set; } = string.Empty;

    /// <summary>Repository the file lives in.</summary>
    [JsonPropertyName("repo")]
    public PushGitHubRepoRef Repo { get => field ??= new(); set; }
}

/// <summary>Pointer to a single-file diff. At least one of `head` and `base` must be present.</summary>
/// <remarks>The <c>github_file_diff</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubFileDiff : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_file_diff";

    /// <summary>File location on the base side of the diff. Absent for additions.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("base")]
    public PushAttachmentGitHubFileDiffSide? Base { get; set; }

    /// <summary>File location on the head side of the diff. Absent for deletions.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("head")]
    public PushAttachmentGitHubFileDiffSide? Head { get; set; }

    /// <summary>URL to the diff on GitHub (e.g., a commit, compare, or PR-file URL).</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>One side of a tree comparison (head or base).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PushAttachmentGitHubTreeComparisonSide
{
    /// <summary>Repository the revision belongs to.</summary>
    [JsonPropertyName("repo")]
    public PushGitHubRepoRef Repo { get => field ??= new(); set; }

    /// <summary>Git revision (branch, tag, or commit SHA).</summary>
    [JsonPropertyName("revision")]
    public string Revision { get; set; } = string.Empty;
}

/// <summary>Pointer to a comparison between two git revisions.</summary>
/// <remarks>The <c>github_tree_comparison</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubTreeComparison : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_tree_comparison";

    /// <summary>Base side of the comparison.</summary>
    [JsonPropertyName("base")]
    public required PushAttachmentGitHubTreeComparisonSide Base { get; set; }

    /// <summary>Head side of the comparison.</summary>
    [JsonPropertyName("head")]
    public required PushAttachmentGitHubTreeComparisonSide Head { get; set; }

    /// <summary>URL to the comparison on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Generic GitHub URL reference.</summary>
/// <remarks>The <c>github_url</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubUrl : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_url";

    /// <summary>URL to the GitHub resource.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a file in a GitHub repository at a specific ref.</summary>
/// <remarks>The <c>github_file</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubFile : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_file";

    /// <summary>Repository-relative path to the file.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Git ref the file is read at (branch, tag, or commit SHA).</summary>
    [JsonPropertyName("ref")]
    public required string Ref { get; set; }

    /// <summary>Repository the file lives in.</summary>
    [JsonPropertyName("repo")]
    public required PushGitHubRepoRef Repo { get; set; }

    /// <summary>URL to the file on GitHub.</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Pointer to a line range inside a file in a GitHub repository.</summary>
/// <remarks>The <c>github_snippet</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentGitHubSnippet : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "github_snippet";

    /// <summary>Line range the snippet covers.</summary>
    [JsonPropertyName("lineRange")]
    public required PushAttachmentFileLineRange LineRange { get; set; }

    /// <summary>Repository-relative path to the file.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }

    /// <summary>Git ref the file is read at (branch, tag, or commit SHA).</summary>
    [JsonPropertyName("ref")]
    public required string Ref { get; set; }

    /// <summary>Repository the file lives in.</summary>
    [JsonPropertyName("repo")]
    public required PushGitHubRepoRef Repo { get; set; }

    /// <summary>URL to the snippet on GitHub (with line anchor).</summary>
    [JsonPropertyName("url")]
    public required string Url { get; set; }
}

/// <summary>Blob attachment with inline base64-encoded data.</summary>
/// <remarks>The <c>blob</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentBlob : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "blob";

    /// <summary>Base64-encoded content.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>User-facing display name for the attachment.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("displayName")]
    public string? DisplayName { get; set; }

    /// <summary>MIME type of the inline data.</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }
}

/// <summary>Slim input shape for extension_context attachments; identity fields are runtime-derived.</summary>
/// <remarks>The <c>extension_context</c> variant of <see cref="PushAttachment"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PushAttachmentExtensionContext : PushAttachment
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "extension_context";

    /// <summary>Caller-supplied JSON payload (required, may be null but not undefined).</summary>
    [JsonPropertyName("payload")]
    public required JsonElement Payload { get; set; }

    /// <summary>Human-readable composer pill label.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("title")]
    public required string Title { get; set; }
}

/// <summary>Parameters for session.extensions.sendAttachmentsToMessage.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SendAttachmentsToMessageParams
{
    /// <summary>Attachments to push into the next user-message turn. extension_context entries take the slim shape; standard variants take their full AttachmentSchema shape.</summary>
    [JsonPropertyName("attachments")]
    public IList<PushAttachment> Attachments { get => field ??= []; set; }

    /// <summary>Optional canvas instance binding the push for provenance. When supplied, the runtime resolves the canvas, verifies it is owned by the calling extension, and stamps canvasId/instanceId onto each extension_context entry. When omitted, no resolution runs and those fields stay unset on the attachment.</summary>
    [JsonPropertyName("instanceId")]
    public string? InstanceId { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A tool name and arguments to execute through the session's native invocation pipeline.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ToolsExecuteRequest
{
    /// <summary>Arguments supplied to the tool.</summary>
    [JsonPropertyName("arguments")]
    public JsonElement Arguments { get; set; }

    /// <summary>Name of the currently offered tool to execute.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional identifier used to correlate this invocation with its tool call.</summary>
    [JsonPropertyName("toolCallId")]
    public string? ToolCallId { get; set; }
}

/// <summary>Custom grammar input format accepted by a built-in tool.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class BuiltinToolFormat
{
    /// <summary>Grammar definition accepted by the tool.</summary>
    [JsonPropertyName("definition")]
    public string Definition { get; set; } = string.Empty;

    /// <summary>Grammar syntax used by the format definition.</summary>
    [JsonPropertyName("syntax")]
    public string Syntax { get; set; } = string.Empty;

    /// <summary>Custom input-format discriminator.</summary>
    [JsonPropertyName("type")]
    public BuiltinToolFormatType Type { get; set; }
}

/// <summary>JSON Schema object accepted by a built-in tool.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class BuiltinToolInputSchema
{
    /// <summary>Root type of the tool input schema.</summary>
    [JsonPropertyName("type")]
    public BuiltinToolInputSchemaType Type { get; set; }
}

/// <summary>Rust-owned metadata and input schema for a built-in tool.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class BuiltinToolDescriptor
{
    /// <summary>Model-facing description of the tool's behavior.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Optional custom input format used instead of a JSON Schema.</summary>
    [JsonPropertyName("format")]
    public BuiltinToolFormat? Format { get; set; }

    /// <summary>Whether the tool provides a specialized intention summary.</summary>
    [JsonPropertyName("hasSummariseIntention")]
    public bool HasSummariseIntention { get; set; }

    /// <summary>JSON Schema for the tool input, or null when the tool uses a custom format.</summary>
    [JsonPropertyName("inputSchema")]
    public BuiltinToolInputSchema? InputSchema { get; set; }

    /// <summary>Optional supplemental usage instructions for the tool.</summary>
    [JsonPropertyName("instructions")]
    public string? Instructions { get; set; }

    /// <summary>Whether the tool executes commands in a terminal.</summary>
    [JsonPropertyName("isTerminal")]
    public bool IsTerminal { get; set; }

    /// <summary>Stable name used to invoke the built-in tool.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Policy describing which tool metadata may be recorded without obfuscation.</summary>
    [JsonPropertyName("safeForTelemetry")]
    public JsonElement SafeForTelemetry { get; set; }

    /// <summary>Optional human-readable title for the tool.</summary>
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>Optional tool category discriminator.</summary>
    [JsonPropertyName("type")]
    public string? Type { get; set; }
}

/// <summary>Rust-owned built-in tool descriptors for the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolsGetBuiltinDescriptorsResult
{
    /// <summary>Built-in tool descriptors materialized for the session.</summary>
    [JsonPropertyName("tools")]
    public IList<BuiltinToolDescriptor> Tools { get => field ??= []; set; }
}

/// <summary>Shell-specific names and description lines used to materialize built-in shell tool descriptors.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolsShellDescriptorConfig
{
    /// <summary>Additional model-facing shell description lines.</summary>
    [JsonPropertyName("descriptionLines")]
    public IList<string> DescriptionLines { get => field ??= []; set; }

    /// <summary>Human-readable shell name.</summary>
    [JsonPropertyName("displayName")]
    public string DisplayName { get; set; } = string.Empty;

    /// <summary>Tool name used to list active shells.</summary>
    [JsonPropertyName("listShellsToolName")]
    public string ListShellsToolName { get; set; } = string.Empty;

    /// <summary>Tool name used to read shell output.</summary>
    [JsonPropertyName("readShellToolName")]
    public string ReadShellToolName { get; set; } = string.Empty;

    /// <summary>Tool name used to start shell commands.</summary>
    [JsonPropertyName("shellToolName")]
    public string ShellToolName { get; set; } = string.Empty;

    /// <summary>Stable shell type identifier.</summary>
    [JsonPropertyName("shellType")]
    public string ShellType { get; set; } = string.Empty;

    /// <summary>Tool name used to stop shell commands.</summary>
    [JsonPropertyName("stopShellToolName")]
    public string StopShellToolName { get; set; } = string.Empty;
}

/// <summary>Options controlling how Rust-owned built-in tool descriptors are materialized.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ToolsGetBuiltinDescriptorsRequest
{
    /// <summary>Whether background task completion notifications are enabled.</summary>
    [JsonPropertyName("backgroundTaskNotificationsEnabled")]
    public bool? BackgroundTaskNotificationsEnabled { get; set; }

    /// <summary>Whether tool descriptors should include authoring metadata.</summary>
    [JsonPropertyName("includeAuthor")]
    public bool? IncludeAuthor { get; set; }

    /// <summary>Whether descriptors should favor fewer user-intervention prompts.</summary>
    [JsonPropertyName("reduceUserIntervention")]
    public bool? ReduceUserIntervention { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Shell-specific names and description lines for shell tools.</summary>
    [JsonPropertyName("shellConfig")]
    public ToolsShellDescriptorConfig? ShellConfig { get; set; }

    /// <summary>Whether the configured shell supports PowerShell 7 syntax.</summary>
    [JsonPropertyName("shellSupportsPowerShell7Syntax")]
    public bool? ShellSupportsPowerShell7Syntax { get; set; }

    /// <summary>Default shell timeout in milliseconds.</summary>
    [JsonPropertyName("shellTimeoutMs")]
    public double? ShellTimeoutMs { get; set; }

    /// <summary>Whether semantic skill lookup is available.</summary>
    [JsonPropertyName("skillEmbeddingEnabled")]
    public bool? SkillEmbeddingEnabled { get; set; }
}

/// <summary>Task completion notification with summary from the agent.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TaskCompleteData
{
    /// <summary>Active autopilot objective ID evaluated by the completion reviewer.</summary>
    [JsonPropertyName("objectiveId")]
    public long? ObjectiveId { get; set; }

    /// <summary>Semantic completion decision. Absent on legacy events and invalid tool calls.</summary>
    [JsonPropertyName("outcome")]
    public TaskCompletionOutcome? Outcome { get; set; }

    /// <summary>Label-safe runtime rationale for the completion decision (e.g. a cancellation or pause/resume downgrade), when one applies. Reviewer-authored rationale is intentionally omitted here because this event has no IFC label channel; the reviewer's findings remain available through its own labeled sub-agent events.</summary>
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Whether the task was accepted as complete. False when validation failed or completion was rejected or blocked by the reviewer.</summary>
    [JsonPropertyName("success")]
    public bool? Success { get; set; }

    /// <summary>Summary of the completed task, provided by the agent.</summary>
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }
}

/// <summary>Binary result returned by a tool for the model.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExternalToolTextResultForLlmBinaryResultsForLlm
{
    /// <summary>Base64-encoded binary data.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public string Data { get; set; } = string.Empty;

    /// <summary>Human-readable description of the binary data.</summary>
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Optional metadata from the producing tool.</summary>
    [JsonPropertyName("metadata")]
    public IDictionary<string, JsonElement>? Metadata { get; set; }

    /// <summary>MIME type of the binary data.</summary>
    [JsonPropertyName("mimeType")]
    public string MimeType { get; set; } = string.Empty;

    /// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
    [JsonPropertyName("type")]
    public ExternalToolTextResultForLlmBinaryResultsForLlmType Type { get; set; }
}

/// <summary>A content block within a tool result, which may be text, terminal output, image, audio, or a resource.</summary>
/// <remarks>Polymorphic base type discriminated by <c>type</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(ExternalToolTextResultForLlmContentText), "text")]
[JsonDerivedType(typeof(ExternalToolTextResultForLlmContentTerminal), "terminal")]
[JsonDerivedType(typeof(ExternalToolTextResultForLlmContentShellExit), "shell_exit")]
[JsonDerivedType(typeof(ExternalToolTextResultForLlmContentImage), "image")]
[JsonDerivedType(typeof(ExternalToolTextResultForLlmContentAudio), "audio")]
[JsonDerivedType(typeof(ExternalToolTextResultForLlmContentResourceLink), "resource_link")]
[JsonDerivedType(typeof(ExternalToolTextResultForLlmContentResource), "resource")]
public partial class ExternalToolTextResultForLlmContent
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("type")]
    public virtual string Type { get; set; } = string.Empty;
}


/// <summary>Plain text content block.</summary>
/// <remarks>The <c>text</c> variant of <see cref="ExternalToolTextResultForLlmContent"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class ExternalToolTextResultForLlmContentText : ExternalToolTextResultForLlmContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "text";

    /// <summary>The text content.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }
}

/// <summary>Terminal/shell output content block with optional exit code and working directory.</summary>
/// <remarks>The <c>terminal</c> variant of <see cref="ExternalToolTextResultForLlmContent"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class ExternalToolTextResultForLlmContentTerminal : ExternalToolTextResultForLlmContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "terminal";

    /// <summary>Working directory where the command was executed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Process exit code, if the command has completed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("exitCode")]
    public long? ExitCode { get; set; }

    /// <summary>Terminal/shell output text.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }
}

/// <summary>Shell command exit metadata with optional output preview.</summary>
/// <remarks>The <c>shell_exit</c> variant of <see cref="ExternalToolTextResultForLlmContent"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class ExternalToolTextResultForLlmContentShellExit : ExternalToolTextResultForLlmContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "shell_exit";

    /// <summary>Working directory where the shell command was executed.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Exit code from the completed shell command.</summary>
    [JsonPropertyName("exitCode")]
    public required long ExitCode { get; set; }

    /// <summary>Path reported in the shell session's filesystem namespace when shell output exceeded the configured large-output threshold.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputFilePath")]
    public string? OutputFilePath { get; set; }

    /// <summary>Output associated with this shell command, if available. May be partial, truncated, or a preview; not guaranteed to be full output.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputPreview")]
    public string? OutputPreview { get; set; }

    /// <summary>Whether outputPreview is known to be incomplete or truncated.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("outputTruncated")]
    public bool? OutputTruncated { get; set; }

    /// <summary>Shell id, as assigned by Copilot runtime.</summary>
    [JsonPropertyName("shellId")]
    public required string ShellId { get; set; }
}

/// <summary>Image content block with base64-encoded data.</summary>
/// <remarks>The <c>image</c> variant of <see cref="ExternalToolTextResultForLlmContent"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class ExternalToolTextResultForLlmContentImage : ExternalToolTextResultForLlmContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "image";

    /// <summary>Base64-encoded image data.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>MIME type of the image (e.g., image/png, image/jpeg).</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }
}

/// <summary>Audio content block with base64-encoded data.</summary>
/// <remarks>The <c>audio</c> variant of <see cref="ExternalToolTextResultForLlmContent"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class ExternalToolTextResultForLlmContentAudio : ExternalToolTextResultForLlmContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "audio";

    /// <summary>Base64-encoded audio data.</summary>
    [Base64String]
    [JsonPropertyName("data")]
    public required string Data { get; set; }

    /// <summary>MIME type of the audio (e.g., audio/wav, audio/mpeg).</summary>
    [JsonPropertyName("mimeType")]
    public required string MimeType { get; set; }
}

/// <summary>Icon image for a resource.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExternalToolTextResultForLlmContentResourceLinkIcon
{
    /// <summary>MIME type of the icon image.</summary>
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Available icon sizes (e.g., ['16x16', '32x32']).</summary>
    [JsonPropertyName("sizes")]
    public IList<string>? Sizes { get; set; }

    /// <summary>URL or path to the icon image.</summary>
    [JsonPropertyName("src")]
    public string Src { get; set; } = string.Empty;

    /// <summary>Theme variant this icon is intended for.</summary>
    [JsonPropertyName("theme")]
    public ExternalToolTextResultForLlmContentResourceLinkIconTheme? Theme { get; set; }
}

/// <summary>Resource link content block referencing an external resource.</summary>
/// <remarks>The <c>resource_link</c> variant of <see cref="ExternalToolTextResultForLlmContent"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class ExternalToolTextResultForLlmContentResourceLink : ExternalToolTextResultForLlmContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "resource_link";

    /// <summary>Human-readable description of the resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("description")]
    public string? Description { get; set; }

    /// <summary>Icons associated with this resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("icons")]
    public IList<ExternalToolTextResultForLlmContentResourceLinkIcon>? Icons { get; set; }

    /// <summary>MIME type of the resource content.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mimeType")]
    public string? MimeType { get; set; }

    /// <summary>Resource name identifier.</summary>
    [JsonPropertyName("name")]
    public required string Name { get; set; }

    /// <summary>Size of the resource in bytes.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("size")]
    public long? Size { get; set; }

    /// <summary>Human-readable display title for the resource.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>URI identifying the resource.</summary>
    [JsonPropertyName("uri")]
    public required string Uri { get; set; }
}

/// <summary>Embedded resource content block with inline text or binary data.</summary>
/// <remarks>The <c>resource</c> variant of <see cref="ExternalToolTextResultForLlmContent"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class ExternalToolTextResultForLlmContentResource : ExternalToolTextResultForLlmContent
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Type => "resource";

    /// <summary>The embedded resource contents, either text or base64-encoded binary.</summary>
    [JsonPropertyName("resource")]
    public required JsonElement Resource { get; set; }
}

/// <summary>A message injected by a tool result.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolResultNewMessage
{
    /// <summary>Message content to inject after the tool result.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Source attributed to the injected message.</summary>
    [JsonPropertyName("source")]
    public string Source { get; set; } = string.Empty;
}

/// <summary>RPC data type for TaskCompletionDecision operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TaskCompletionDecision
{
    /// <summary>Objective eligibility token captured when the decision was evaluated.</summary>
    [JsonPropertyName("completionEligibilityToken")]
    public long? CompletionEligibilityToken { get; set; }

    /// <summary>Whether completion was accepted after the reviewer-rejection budget was exhausted.</summary>
    [JsonPropertyName("completionRejectionBudgetExhausted")]
    public bool? CompletionRejectionBudgetExhausted { get; set; }

    /// <summary>Active autopilot objective evaluated by the completion reviewer.</summary>
    [JsonPropertyName("objectiveId")]
    public long? ObjectiveId { get; set; }

    /// <summary>Semantic result of evaluating the task completion request.</summary>
    [JsonPropertyName("outcome")]
    public TaskCompletionOutcome Outcome { get; set; }

    /// <summary>Rationale for the completion decision, when one is available.</summary>
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }

    /// <summary>Whether the rationale was derived from completion-reviewer output.</summary>
    [JsonPropertyName("reviewerDerived")]
    public bool? ReviewerDerived { get; set; }

    /// <summary>Information-flow metadata captured from the completion reviewer.</summary>
    [JsonPropertyName("reviewerResultMeta")]
    public JsonElement? ReviewerResultMeta { get; set; }
}

/// <summary>Expanded canonical result returned by a session tool.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolResultExpanded
{
    /// <summary>Base64-encoded binary results returned to the model.</summary>
    [JsonPropertyName("binaryResultsForLlm")]
    public IList<ExternalToolTextResultForLlmBinaryResultsForLlm>? BinaryResultsForLlm { get; set; }

    /// <summary>Sources returned by the tool that the model may cite.</summary>
    [JsonPropertyName("citableSources")]
    public IList<JsonElement>? CitableSources { get; set; }

    /// <summary>Structured content blocks returned to the model.</summary>
    [JsonPropertyName("contents")]
    public IList<ExternalToolTextResultForLlmContent>? Contents { get; set; }

    /// <summary>Error message for an unsuccessful execution.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Metadata propagated with the tool result, including information-flow labels.</summary>
    [JsonPropertyName("mcpMeta")]
    public IDictionary<string, JsonElement>? McpMeta { get; set; }

    /// <summary>Messages to inject after the tool result.</summary>
    [JsonPropertyName("newMessages")]
    public IList<ToolResultNewMessage>? NewMessages { get; set; }

    /// <summary>Whether post-tool-use failure hooks have already processed this result.</summary>
    [JsonPropertyName("postToolUseFailureHooksProcessed")]
    public bool? PostToolUseFailureHooksProcessed { get; set; }

    /// <summary>Execution outcome classification.</summary>
    [JsonPropertyName("resultType")]
    public ToolResultType ResultType { get; set; }

    /// <summary>Detailed log content available for session display.</summary>
    [JsonPropertyName("sessionLog")]
    public string? SessionLog { get; set; }

    /// <summary>Skill invocation metadata produced by the tool.</summary>
    [JsonPropertyName("skillInvocation")]
    public JsonElement? SkillInvocation { get; set; }

    /// <summary>Whether large-output post-processing should be skipped.</summary>
    [JsonPropertyName("skipLargeOutputProcessing")]
    public bool? SkipLargeOutputProcessing { get; set; }

    /// <summary>Structured result content in addition to the model-facing text.</summary>
    [JsonPropertyName("structuredContent")]
    public JsonElement? StructuredContent { get; set; }

    /// <summary>Completion-review decision produced by the task-completion tool.</summary>
    [JsonPropertyName("taskCompletionDecision")]
    public TaskCompletionDecision? TaskCompletionDecision { get; set; }

    /// <summary>Text result returned to the model.</summary>
    [JsonPropertyName("textResultForLlm")]
    public string TextResultForLlm { get; set; } = string.Empty;

    /// <summary>Deferred tool names made available by this result.</summary>
    [JsonPropertyName("toolReferences")]
    public IList<string>? ToolReferences { get; set; }

    /// <summary>Tool-specific telemetry payload.</summary>
    [JsonPropertyName("toolTelemetry")]
    public JsonElement? ToolTelemetry { get; set; }

    /// <summary>Optional UI resource produced by the tool.</summary>
    [JsonPropertyName("uiResource")]
    public JsonElement? UiResource { get; set; }
}

/// <summary>Task-completion tool arguments and final result used to build a label-safe session event payload.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ToolsTaskCompleteEventDataRequest
{
    /// <summary>Final expanded result returned by the task_complete tool.</summary>
    [JsonPropertyName("finalResult")]
    public ToolResultExpanded FinalResult { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Arguments supplied to the completed task_complete tool call.</summary>
    [JsonPropertyName("toolArgs")]
    public JsonElement ToolArgs { get; set; }
}

/// <summary>Indicates whether the external tool call result was handled successfully.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HandlePendingToolCallResult
{
    /// <summary>Whether the tool call result was handled successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Pending external tool call request ID, with the tool result or an error describing why it failed.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class HandlePendingToolCallRequest
{
    /// <summary>Error message if the tool call failed.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Request ID of the pending tool call.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Tool call result (string or expanded result object).</summary>
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Resolve, build, and validate the runtime tool list for this session. Subagent sessions and consumer flows that need an initialized tool set before `send` invoke this. Default base-class implementation is a no-op for sessions that don't support tool validation.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolsInitializeAndValidateResult
{
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionToolsInitializeAndValidateRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Lightweight metadata for a currently initialized session tool.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CurrentToolMetadata
{
    /// <summary>Whether the tool is loaded on demand via tool search.</summary>
    [JsonPropertyName("deferLoading")]
    public bool? DeferLoading { get; set; }

    /// <summary>Tool description.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>JSON Schema for tool input.</summary>
    [JsonPropertyName("input_schema")]
    public IDictionary<string, JsonElement>? InputSchema { get; set; }

    /// <summary>MCP server name for MCP-backed tools.</summary>
    [JsonPropertyName("mcpServerName")]
    public string? McpServerName { get; set; }

    /// <summary>Raw MCP tool name for MCP-backed tools.</summary>
    [JsonPropertyName("mcpToolName")]
    public string? McpToolName { get; set; }

    /// <summary>Model-facing tool name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Optional MCP/config namespaced tool name.</summary>
    [JsonPropertyName("namespacedName")]
    public string? NamespacedName { get; set; }
}

/// <summary>Current lightweight tool metadata snapshot for the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolsGetCurrentMetadataResult
{
    /// <summary>Current tool metadata, or null when tools have not been initialized yet.</summary>
    [JsonPropertyName("tools")]
    public IList<CurrentToolMetadata>? Tools { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionToolsGetCurrentMetadataRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Empty result after replacing the calling connection's externally implemented tools.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolsSetResult
{
}

/// <summary>Serializable definition of a caller-implemented tool whose execution is handled over the SDK connection.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProtocolExternalToolDefinition
{
    /// <summary>Tool-loading deferral policy.</summary>
    [JsonPropertyName("defer")]
    public ProtocolExternalToolDefer? Defer { get; set; }

    /// <summary>Model-visible explanation of what the tool does.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Whether the tool executes commands in a terminal.</summary>
    [JsonPropertyName("isTerminal")]
    public bool? IsTerminal { get; set; }

    /// <summary>Optional caller-defined metadata associated with the tool.</summary>
    [JsonPropertyName("metadata")]
    public IDictionary<string, JsonElement>? Metadata { get; set; }

    /// <summary>Unique model-visible tool name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Whether this definition replaces a built-in tool with the same name.</summary>
    [JsonPropertyName("overridesBuiltInTool")]
    public bool? OverridesBuiltInTool { get; set; }

    /// <summary>JSON Schema describing the tool's input arguments.</summary>
    [JsonPropertyName("parameters")]
    public IDictionary<string, JsonElement>? Parameters { get; set; }

    /// <summary>Whether execution bypasses the normal tool permission prompt.</summary>
    [JsonPropertyName("skipPermission")]
    public bool? SkipPermission { get; set; }

    /// <summary>Optional human-readable display title.</summary>
    [JsonPropertyName("title")]
    public string? Title { get; set; }
}

/// <summary>Complete externally implemented tool list for the calling connection. An empty list removes every tool previously supplied by that connection.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ToolsSetRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Complete replacement list for the calling connection.</summary>
    [JsonPropertyName("tools")]
    public IList<ProtocolExternalToolDefinition> Tools { get => field ??= []; set; }
}

/// <summary>Empty result after applying subagent settings.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolsUpdateSubagentSettingsResult
{
}

/// <summary>Subagent model, reasoning effort, context tier, and auto-invocation settings.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SubagentSettingsEntry
{
    /// <summary>Whether this agent's runtime-defined proactive invocation prompting is enabled, if supported. Currently consumed by the built-in rubber-duck agent.</summary>
    [JsonPropertyName("autoInvoke")]
    public bool? AutoInvoke { get; set; }

    /// <summary>Context tier override for matching subagents.</summary>
    [JsonPropertyName("contextTier")]
    public SubagentSettingsEntryContextTier? ContextTier { get; set; }

    /// <summary>Reasoning effort override for matching subagents.</summary>
    [JsonPropertyName("effortLevel")]
    public string? EffortLevel { get; set; }

    /// <summary>Model override for matching subagents.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }

    /// <summary>Whether the configured model strategy is preferred or required.</summary>
    [JsonPropertyName("modelPolicy")]
    public AgentModelPolicy? ModelPolicy { get; set; }
}

/// <summary>Configured per-agent subagent overrides.</summary>
public sealed class UpdateSubagentSettingsRequestSubagents
{
    /// <summary>Per-agent settings keyed by subagent agent_type.</summary>
    [JsonPropertyName("agents")]
    public IDictionary<string, SubagentSettingsEntry>? Agents { get; set; }

    /// <summary>Names of subagents the user has turned off; they cannot be dispatched.</summary>
    [JsonPropertyName("disabledSubagents")]
    public IList<string>? DisabledSubagents { get; set; }

    /// <summary>Maximum number of subagents that can run concurrently; applies to usage-based billing users only.</summary>
    [JsonPropertyName("maxConcurrency")]
    public int? MaxConcurrency { get; set; }

    /// <summary>Maximum subagent nesting depth; applies to usage-based billing users only.</summary>
    [JsonPropertyName("maxDepth")]
    public int? MaxDepth { get; set; }
}

/// <summary>Subagent settings to apply to the current session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UpdateSubagentSettingsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Subagent settings to apply, or null to clear the live session override.</summary>
    [JsonPropertyName("subagents")]
    public UpdateSubagentSettingsRequestSubagents? Subagents { get; set; }
}

/// <summary>RPC data type for SessionCommandsList operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionCommandsListRequest
{
    /// <summary>Include runtime built-in commands.</summary>
    [JsonPropertyName("includeBuiltins")]
    public bool? IncludeBuiltins { get; set; }

    /// <summary>Include commands registered by protocol clients, including SDK clients and extensions.</summary>
    [JsonPropertyName("includeClientCommands")]
    public bool? IncludeClientCommands { get; set; }

    /// <summary>Include enabled user-invocable skills and commands.</summary>
    [JsonPropertyName("includeSkills")]
    public bool? IncludeSkills { get; set; }
}

/// <summary>RPC data type for SessionCommandsListRequestWithSession operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionCommandsListRequestWithSession
{
    /// <summary>Include runtime built-in commands.</summary>
    [JsonPropertyName("includeBuiltins")]
    public bool? IncludeBuiltins { get; set; }

    /// <summary>Include commands registered by protocol clients, including SDK clients and extensions.</summary>
    [JsonPropertyName("includeClientCommands")]
    public bool? IncludeClientCommands { get; set; }

    /// <summary>Include enabled user-invocable skills and commands.</summary>
    [JsonPropertyName("includeSkills")]
    public bool? IncludeSkills { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of invoking the slash command (text output, prompt to send to the agent, completion, or subcommand selection).</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(SlashCommandInvocationResultText), "text")]
[JsonDerivedType(typeof(SlashCommandInvocationResultAgentPrompt), "agent-prompt")]
[JsonDerivedType(typeof(SlashCommandInvocationResultCompleted), "completed")]
[JsonDerivedType(typeof(SlashCommandInvocationResultSelectSubcommand), "select-subcommand")]
[JsonDerivedType(typeof(SlashCommandInvocationResultAddTimelineEntry), "add-timeline-entry")]
[JsonDerivedType(typeof(SlashCommandInvocationResultShowDialog), "show-dialog")]
[JsonDerivedType(typeof(SlashCommandInvocationResultSetModel), "set-model")]
[JsonDerivedType(typeof(SlashCommandInvocationResultSetPlanModel), "set-plan-model")]
public partial class SlashCommandInvocationResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Slash-command invocation result containing text output plus Markdown/ANSI rendering flags.</summary>
/// <remarks>The <c>text</c> variant of <see cref="SlashCommandInvocationResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultText : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "text";

    /// <summary>Whether text contains Markdown.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("markdown")]
    public bool? Markdown { get; set; }

    /// <summary>Whether ANSI sequences should be preserved.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("preserveAnsi")]
    public bool? PreserveAnsi { get; set; }

    /// <summary>True when the invocation mutated user runtime settings; consumers caching settings should refresh.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }

    /// <summary>Text output for the client to render.</summary>
    [JsonPropertyName("text")]
    public required string Text { get; set; }
}

/// <summary>Slash-command invocation result that submits an agent prompt, with display prompt, optional mode, optional user-facing notice, and settings-change flag.</summary>
/// <remarks>The <c>agent-prompt</c> variant of <see cref="SlashCommandInvocationResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultAgentPrompt : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "agent-prompt";

    /// <summary>Prompt text to display to the user.</summary>
    [JsonPropertyName("displayPrompt")]
    public required string DisplayPrompt { get; set; }

    /// <summary>Optional target session mode for the agent prompt.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mode")]
    public SessionMode? Mode { get; set; }

    /// <summary>Optional user-facing notice to show before the prompt is submitted.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("notice")]
    public string? Notice { get; set; }

    /// <summary>Prompt to submit to the agent.</summary>
    [JsonPropertyName("prompt")]
    public required string Prompt { get; set; }

    /// <summary>True when the invocation mutated user runtime settings; consumers caching settings should refresh.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }
}

/// <summary>Slash-command invocation result indicating completion, with optional message and settings-change flag.</summary>
/// <remarks>The <c>completed</c> variant of <see cref="SlashCommandInvocationResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultCompleted : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "completed";

    /// <summary>Optional user-facing message describing the completed command.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("message")]
    public string? Message { get; set; }

    /// <summary>Optional target session mode applied without submitting an agent prompt.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("mode")]
    public SessionMode? Mode { get; set; }

    /// <summary>True when the invocation mutated user runtime settings; consumers caching settings should refresh.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }
}

/// <summary>Selectable slash-command subcommand option with name, description, and optional group label.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SlashCommandSelectSubcommandOption
{
    /// <summary>Human-readable description of the subcommand.</summary>
    [JsonPropertyName("description")]
    public string Description { get; set; } = string.Empty;

    /// <summary>Optional group label for organizing options.</summary>
    [JsonPropertyName("group")]
    public string? Group { get; set; }

    /// <summary>Subcommand name to invoke.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;
}

/// <summary>Slash-command invocation result asking the client to present subcommand options for a parent command.</summary>
/// <remarks>The <c>select-subcommand</c> variant of <see cref="SlashCommandInvocationResult"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultSelectSubcommand : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "select-subcommand";

    /// <summary>Parent command name that requires subcommand selection.</summary>
    [JsonPropertyName("command")]
    public required string Command { get; set; }

    /// <summary>Available subcommand options for the client to present.</summary>
    [JsonPropertyName("options")]
    public required IList<SlashCommandSelectSubcommandOption> Options { get; set; }

    /// <summary>True when the invocation mutated user runtime settings; consumers caching settings should refresh.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }

    /// <summary>Human-readable title for the selection UI.</summary>
    [JsonPropertyName("title")]
    public required string Title { get; set; }
}

/// <summary>RPC data type for SlashCommandTimelineEntry operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SlashCommandTimelineEntry
{
    /// <summary>What the user must do to recover, when the entry reports a failure the runtime knows an action for. The `text` never names a client affordance, so a client that offers one renders it from this value.</summary>
    [JsonPropertyName("remediation")]
    public RemediationAction? Remediation { get; set; }

    /// <summary>Text displayed for the timeline entry.</summary>
    [JsonPropertyName("text")]
    public string Text { get; set; } = string.Empty;

    /// <summary>Timeline entry presentation type.</summary>
    [JsonPropertyName("type")]
    public string Type { get; set; } = string.Empty;

    /// <summary>Optional URL associated with the timeline entry.</summary>
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>The <c>add-timeline-entry</c> variant of <see cref="SlashCommandInvocationResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultAddTimelineEntry : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "add-timeline-entry";

    /// <summary>Timeline entry the host should append.</summary>
    [JsonPropertyName("entry")]
    public required SlashCommandTimelineEntry Entry { get; set; }

    /// <summary>Optional text the host should prefill into the input editor.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("prefillInput")]
    public string? PrefillInput { get; set; }

    /// <summary>Whether command execution changed persisted runtime settings.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }
}

/// <summary>RPC data type for SlashCommandModelPickerDialog operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SlashCommandModelPickerDialog
{
    /// <summary>Discriminator for a model-picker dialog.</summary>
    [JsonPropertyName("kind")]
    public string Kind { get; set; } = string.Empty;

    /// <summary>Model that should be enabled before it can be selected.</summary>
    [JsonPropertyName("modelToEnable")]
    public string? ModelToEnable { get; set; }

    /// <summary>Settings scope the picker should modify.</summary>
    [JsonPropertyName("scope")]
    public string? Scope { get; set; }

    /// <summary>Model-selection target represented by the picker.</summary>
    [JsonPropertyName("target")]
    public string? Target { get; set; }
}

/// <summary>The <c>show-dialog</c> variant of <see cref="SlashCommandInvocationResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultShowDialog : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "show-dialog";

    /// <summary>Dialog the host should display.</summary>
    [JsonPropertyName("dialog")]
    public required SlashCommandModelPickerDialog Dialog { get; set; }

    /// <summary>Whether command execution changed persisted runtime settings.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }
}

/// <summary>User-settings snapshot to restore if the host cancels the model switch.</summary>
public sealed class SlashCommandInvocationResultSetModelRevertOnCancel
{
}

/// <summary>The <c>set-model</c> variant of <see cref="SlashCommandInvocationResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultSetModel : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "set-model";

    /// <summary>Model selected by the command.</summary>
    [JsonPropertyName("model")]
    public required string Model { get; set; }

    /// <summary>Reasoning effort selected for the model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reasoningEffort")]
    public string? ReasoningEffort { get; set; }

    /// <summary>Repository settings scope modified by the command.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("repoScope")]
    public string? RepoScope { get; set; }

    /// <summary>User-settings snapshot to restore if the host cancels the model switch.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("revertOnCancel")]
    public SlashCommandInvocationResultSetModelRevertOnCancel? RevertOnCancel { get; set; }

    /// <summary>Whether command execution changed persisted runtime settings.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }

    /// <summary>Settings scope modified by the command.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("scope")]
    public string? Scope { get; set; }

    /// <summary>User-facing warning produced while selecting the model.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("warning")]
    public string? Warning { get; set; }
}

/// <summary>The <c>set-plan-model</c> variant of <see cref="SlashCommandInvocationResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SlashCommandInvocationResultSetPlanModel : SlashCommandInvocationResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "set-plan-model";

    /// <summary>User-facing confirmation message for the plan-model selection.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>Dedicated model selected for plan mode.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("planModel")]
    public string? PlanModel { get; set; }

    /// <summary>Whether command execution changed persisted runtime settings.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("runtimeSettingsChanged")]
    public bool? RuntimeSettingsChanged { get; set; }
}

/// <summary>Slash command name and optional raw input string to invoke.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CommandsInvokeRequest
{
    /// <summary>Raw input after the command name.</summary>
    [JsonPropertyName("input")]
    public string? Input { get; set; }

    /// <summary>Command name. Leading slashes are stripped and the name is matched case-insensitively.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Optional client surface that initiated the invocation.</summary>
    [JsonPropertyName("origin")]
    public CommandsInvocationOrigin? Origin { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Whether finalizing the invocation effect succeeded, and the failure reason when it did not.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CommandsFinalizeInvocationEffectResult
{
    /// <summary>Failure reason when the invocation effect could not be finalized.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Whether the pending invocation effect was finalized successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>The slash-command result object that produced the pending effect, echoed back unchanged.</summary>
public sealed class CommandsFinalizeInvocationEffectRequestEffect
{
}

/// <summary>The pending slash-command invocation effect to finalize, plus whether the host applied or cancelled it.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CommandsFinalizeInvocationEffectRequest
{
    /// <summary>The slash-command result object that produced the pending effect, echoed back unchanged.</summary>
    [JsonPropertyName("effect")]
    public CommandsFinalizeInvocationEffectRequestEffect Effect { get => field ??= new(); set; }

    /// <summary>Whether the host applied or cancelled the pending invocation effect.</summary>
    [JsonPropertyName("outcome")]
    public CommandsInvocationEffectOutcome Outcome { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the pending client-handled command was completed successfully.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CommandsHandlePendingCommandResult
{
    /// <summary>Whether the command was handled successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Pending command request ID and an optional error if the client handler failed.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CommandsHandlePendingCommandRequest
{
    /// <summary>Error message if the command handler failed.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Request ID from the command invocation event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Error message produced while executing the command, if any.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExecuteCommandResult
{
    /// <summary>Error message produced while executing the command, if any. Omitted when the handler succeeded.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }
}

/// <summary>Slash command name and argument string to execute synchronously.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ExecuteCommandParams
{
    /// <summary>Argument string to pass to the command (empty string if none).</summary>
    [JsonPropertyName("args")]
    public string Args { get; set; } = string.Empty;

    /// <summary>Name of the slash command to invoke (without the leading '/').</summary>
    [JsonPropertyName("commandName")]
    public string CommandName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the command was accepted into the local execution queue.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class EnqueueCommandResult
{
    /// <summary>True when the command was accepted into the local execution queue. False when the call targets a session that does not support local command queueing (e.g. remote sessions).</summary>
    [JsonPropertyName("queued")]
    public bool Queued { get; set; }
}

/// <summary>Slash-prefixed command string to enqueue for FIFO processing.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class EnqueueCommandParams
{
    /// <summary>Slash-prefixed command string to enqueue, e.g. '/compact' or '/model gpt-4'. Queued FIFO with any in-flight items; if the session is idle, processing kicks off immediately.</summary>
    [JsonPropertyName("command")]
    public string Command { get; set; } = string.Empty;

    /// <summary>Optional user-facing text for the queue row. The command string is shown when omitted.</summary>
    [JsonPropertyName("displayText")]
    public string? DisplayText { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the queued-command response was matched to a pending request.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CommandsRespondToQueuedCommandResult
{
    /// <summary>Whether a pending queued command with the given request ID was found and resolved. False when the request was already resolved, cancelled, or unknown.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Result of the queued command execution.</summary>
/// <remarks>Data type discriminated by <c>handled</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class QueuedCommandResult
{
    /// <summary>The boolean discriminator.</summary>
    [JsonPropertyName("handled")]
    public bool Handled { get; set; }

    /// <summary>When true, the runtime will not process subsequent queued commands until a new request comes in.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("stopProcessingQueue")]
    public bool? StopProcessingQueue { get; set; }
}

/// <summary>Queued-command request ID and the result indicating whether the host executed it (and whether to stop processing further queued commands).</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class CommandsRespondToQueuedCommandRequest
{
    /// <summary>Request ID from the `command.queued` event the host is responding to.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Result of the queued command execution.</summary>
    [JsonPropertyName("result")]
    public QueuedCommandResult Result { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Telemetry engagement ID for the session, when available.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionTelemetryEngagement
{
    /// <summary>Current telemetry engagement ID, when available.</summary>
    [JsonPropertyName("engagementId")]
    public string? EngagementId { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionTelemetryGetEngagementIdRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Feature override key/value pairs to attach to subsequent telemetry events from this session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class TelemetrySetFeatureOverridesRequest
{
    /// <summary>Override key/value pairs to attach to subsequent telemetry events from this session. Replaces any previously-set overrides.</summary>
    [JsonPropertyName("features")]
    public IDictionary<string, string> Features { get => field ??= new Dictionary<string, string>(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Completed transient query. Ordered chunks and the terminal outcome are also delivered through `ui.ephemeral_query` session events while it runs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIEphemeralQueryResult
{
    /// <summary>Answer returned by the model.</summary>
    [JsonPropertyName("answer")]
    public string Answer { get; set; } = string.Empty;
}

/// <summary>Transient question to answer without adding it to conversation history.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIEphemeralQueryRequest
{
    /// <summary>Question to answer from the current conversation context.</summary>
    [JsonPropertyName("question")]
    public string Question { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>MCP response metadata.</summary>
public sealed class UIElicitationResponseMeta
{
}

/// <summary>The elicitation response (accept with form values, decline, or cancel).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIElicitationResponse
{
    /// <summary>MCP response metadata.</summary>
    [JsonPropertyName("_meta")]
    public UIElicitationResponseMeta? Meta { get; set; }

    /// <summary>The user's response: accept (submitted), decline (rejected), or cancel (dismissed).</summary>
    [JsonPropertyName("action")]
    public UIElicitationResponseAction Action { get; set; }

    /// <summary>The form values submitted by the user (present when action is 'accept').</summary>
    [JsonPropertyName("content")]
    public IDictionary<string, JsonElement>? Content { get; set; }
}

/// <summary>MCP request metadata.</summary>
public sealed class UIElicitationRequestMeta
{
}

/// <summary>JSON Schema describing the form fields to present to the user.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIElicitationSchema
{
    /// <summary>Form field definitions, keyed by field name.</summary>
    [JsonPropertyName("properties")]
    public IDictionary<string, JsonElement> Properties { get => field ??= new Dictionary<string, JsonElement>(); set; }

    /// <summary>List of required field names.</summary>
    [JsonPropertyName("required")]
    public IList<string>? Required { get; set; }

    /// <summary>Schema type indicator (always 'object').</summary>
    [JsonPropertyName("type")]
    public string Type { get; set; } = string.Empty;
}

/// <summary>Metadata controlling an MCP task's lifetime.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpTaskMetadata
{
    /// <summary>Task time-to-live.</summary>
    [JsonPropertyName("ttl")]
    public long? Ttl { get; set; }
}

/// <summary>Prompt message and JSON schema describing the form fields to elicit from the user.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIElicitationRequest
{
    /// <summary>MCP request metadata.</summary>
    [JsonPropertyName("_meta")]
    public UIElicitationRequestMeta? Meta { get; set; }

    /// <summary>Message describing what information is needed from the user.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>Elicitation mode. Omitted and form are equivalent for structured elicitation.</summary>
    [JsonPropertyName("mode")]
    public McpElicitationFormMode? Mode { get; set; }

    /// <summary>JSON Schema describing the form fields to present to the user.</summary>
    [JsonPropertyName("requestedSchema")]
    public UIElicitationSchema RequestedSchema { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>MCP task metadata.</summary>
    [JsonPropertyName("task")]
    public McpTaskMetadata? Task { get; set; }
}

/// <summary>Indicates whether the elicitation response was accepted; false if it was already resolved by another client.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIElicitationResult
{
    /// <summary>Whether the response was accepted. False if the request was already resolved by another client.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Pending elicitation request ID and the user's response (accept/decline/cancel + form values).</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIHandlePendingElicitationRequest
{
    /// <summary>The unique request ID from the elicitation.requested event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>The elicitation response (accept with form values, decline, or cancel).</summary>
    [JsonPropertyName("result")]
    public UIElicitationResponse Result { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the pending UI request was resolved by this call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIHandlePendingResult
{
    /// <summary>True if the request was still pending and was resolved by this call. False if the request ID was unknown, already resolved by another client (e.g. GitHub), expired, or otherwise no longer pending.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>User response for a pending user-input request, with answer text and whether it was typed freeform.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIUserInputResponse
{
    /// <summary>The user's answer text.</summary>
    [JsonPropertyName("answer")]
    public string Answer { get; set; } = string.Empty;

    /// <summary>True if the user typed a freeform response, false if they selected a presented choice. Used by telemetry to differentiate between free text input and choice selection.</summary>
    [JsonPropertyName("wasFreeform")]
    public bool WasFreeform { get; set; }
}

/// <summary>Request ID of a pending `user_input.requested` event and the user's response.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIHandlePendingUserInputRequest
{
    /// <summary>The unique request ID from the user_input.requested event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>User response for a pending user-input request, with answer text and whether it was typed freeform.</summary>
    [JsonPropertyName("response")]
    public UIUserInputResponse Response { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Optional sampling result payload. Omit to reject/cancel the sampling request without providing a result.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIHandlePendingSamplingResponse
{
}

/// <summary>Request ID of a pending `sampling.requested` event and an optional sampling result payload (omit to reject).</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIHandlePendingSamplingRequest
{
    /// <summary>The unique request ID from the sampling.requested event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Optional sampling result payload. Omit to reject/cancel the sampling request without providing a result.</summary>
    [JsonPropertyName("response")]
    public UIHandlePendingSamplingResponse? Response { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Request ID of a pending `auto_mode_switch.requested` event and the user's response.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIHandlePendingAutoModeSwitchRequest
{
    /// <summary>The unique request ID from the auto_mode_switch.requested event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>User's choice for auto-mode switching: yes (allow this turn), yes_always (allow + persist as setting), or no (decline).</summary>
    [JsonPropertyName("response")]
    public UIAutoModeSwitchResponse Response { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The user's selected action for an exhausted session limit.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UISessionLimitsExhaustedResponse
{
    /// <summary>Action selected by the user.</summary>
    [JsonPropertyName("action")]
    public UISessionLimitsExhaustedResponseAction Action { get; set; }

    /// <summary>AI Credits to add to the current max when action is 'add'.</summary>
    [JsonPropertyName("additionalAiCredits")]
    public double? AdditionalAiCredits { get; set; }

    /// <summary>New absolute max AI Credits when action is 'set'.</summary>
    [JsonPropertyName("maxAiCredits")]
    public double? MaxAiCredits { get; set; }
}

/// <summary>Request ID of a pending `session_limits_exhausted.requested` event and the user's selected limit action.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIHandlePendingSessionLimitsExhaustedRequest
{
    /// <summary>The unique request ID from the session_limits_exhausted.requested event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>The selected session-limit action.</summary>
    [JsonPropertyName("response")]
    public UISessionLimitsExhaustedResponse Response { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>User response for a pending exit-plan-mode request, with approval state, selected action, auto-approve flag, and feedback.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIExitPlanModeResponse
{
    /// <summary>Whether the plan was approved.</summary>
    [JsonPropertyName("approved")]
    public bool Approved { get; set; }

    /// <summary>Whether subsequent edits should be auto-approved without confirmation.</summary>
    [JsonPropertyName("autoApproveEdits")]
    public bool? AutoApproveEdits { get; set; }

    /// <summary>When true, the agent is instructed to end its turn without starting implementation so the client can restore the session model and auto-submit a fresh implementation turn on it. Set only when a distinct plan configuration (a different model, reasoning effort, or context tier) actually ran the planning turn.</summary>
    [JsonPropertyName("deferImplementation")]
    public bool? DeferImplementation { get; set; }

    /// <summary>Feedback from the user when they declined the plan or requested changes.</summary>
    [JsonPropertyName("feedback")]
    public string? Feedback { get; set; }

    /// <summary>The action the user selected. Defaults to 'autopilot' when autoApproveEdits is true, otherwise 'interactive'.</summary>
    [JsonPropertyName("selectedAction")]
    public UIExitPlanModeAction? SelectedAction { get; set; }
}

/// <summary>Request ID of a pending `exit_plan_mode.requested` event and the user's response.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIHandlePendingExitPlanModeRequest
{
    /// <summary>The unique request ID from the exit_plan_mode.requested event.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>User response for a pending exit-plan-mode request, with approval state, selected action, auto-approve flag, and feedback.</summary>
    [JsonPropertyName("response")]
    public UIExitPlanModeResponse Response { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Register an in-process handler for `auto_mode_switch.requested` events. The caller still attaches the actual listener via the standard event-subscription mechanism; this registration solely tells the server bridge to skip its own dispatch (so a remote client doesn't race the in-process handler for the same requestId).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIRegisterDirectAutoModeSwitchHandlerResult
{
    /// <summary>Opaque handle representing the registration. Pass this same handle to `unregisterDirectAutoModeSwitchHandler` when the in-process handler is no longer active. Multiple registrations are reference-counted; the server bridge will only dispatch auto-mode-switch requests when no handles are active.</summary>
    [JsonPropertyName("handle")]
    public string Handle { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionUiRegisterDirectAutoModeSwitchHandlerRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the handle was active and the registration count was decremented.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UIUnregisterDirectAutoModeSwitchHandlerResult
{
    /// <summary>True if the handle was active and decremented the counter; false if the handle was unknown.</summary>
    [JsonPropertyName("unregistered")]
    public bool Unregistered { get; set; }
}

/// <summary>Opaque handle previously returned by `registerDirectAutoModeSwitchHandler` to release.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class UIUnregisterDirectAutoModeSwitchHandlerRequest
{
    /// <summary>Handle previously returned by `registerDirectAutoModeSwitchHandler`.</summary>
    [JsonPropertyName("handle")]
    public string Handle { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsConfigureResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Source descriptor for a `session.permissions.configure` content-exclusion rule, with source name and type.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsConfigureAdditionalContentExclusionPolicyRuleSource
{
    /// <summary>Name of the policy source.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Type of the policy source.</summary>
    [JsonPropertyName("type")]
    public string Type { get; set; } = string.Empty;
}

/// <summary>Single content-exclusion rule supplied to `session.permissions.configure`, with paths, match conditions, and source.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsConfigureAdditionalContentExclusionPolicyRule
{
    /// <summary>Conditions of which at least one must match.</summary>
    [JsonPropertyName("ifAnyMatch")]
    public IList<string>? IfAnyMatch { get; set; }

    /// <summary>Conditions none of which may match.</summary>
    [JsonPropertyName("ifNoneMatch")]
    public IList<string>? IfNoneMatch { get; set; }

    /// <summary>Path patterns covered by this rule.</summary>
    [JsonPropertyName("paths")]
    public IList<string> Paths { get => field ??= []; set; }

    /// <summary>Source descriptor for a `session.permissions.configure` content-exclusion rule, with source name and type.</summary>
    [JsonPropertyName("source")]
    public PermissionsConfigureAdditionalContentExclusionPolicyRuleSource Source { get => field ??= new(); set; }
}

/// <summary>Content-exclusion policy supplied to `session.permissions.configure`, with rules, last-updated data, and scope.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsConfigureAdditionalContentExclusionPolicy
{
    /// <summary>Opaque policy update timestamp supplied by the host.</summary>
    [JsonPropertyName("last_updated_at")]
    public JsonElement LastUpdatedAt { get; set; }

    /// <summary>Content-exclusion rules to apply.</summary>
    [JsonPropertyName("rules")]
    public IList<PermissionsConfigureAdditionalContentExclusionPolicyRule> Rules { get => field ??= []; set; }

    /// <summary>Allowed values for the `PermissionsConfigureAdditionalContentExclusionPolicyScope` enumeration.</summary>
    [JsonPropertyName("scope")]
    public PermissionsConfigureAdditionalContentExclusionPolicyScope Scope { get; set; }
}

/// <summary>If specified, replaces the session's path-permission policy. The runtime constructs the appropriate PathManager based on these inputs (rooted at the session's working directory). Omit to leave the current path policy unchanged.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionPathsConfig
{
    /// <summary>Additional directories to allow tool access to (in addition to the session's working directory). Conventional `.github/skills/` and `.github/agents/` definitions under them also join the session catalogs when their subsystem gates are enabled, so supplying a directory is a trust decision for configuration stored there. When `unrestricted` is true, these are still pre-populated on the UnrestrictedPathManager so they remain visible via getDirectories() (e.g. for @-mention completion).</summary>
    [JsonPropertyName("additionalDirectories")]
    public IList<string>? AdditionalDirectories { get; set; }

    /// <summary>Whether to include the system temp directory in the allowed list (defaults to true). Ignored when `unrestricted` is true.</summary>
    [JsonPropertyName("includeTempDirectory")]
    public bool? IncludeTempDirectory { get; set; }

    /// <summary>If true, the runtime allows access to all paths without prompting. Equivalent to constructing an UnrestrictedPathManager.</summary>
    [JsonPropertyName("unrestricted")]
    public bool? Unrestricted { get; set; }

    /// <summary>Workspace root path (special-cased to be allowed even before the directory exists). Ignored when `unrestricted` is true.</summary>
    [JsonPropertyName("workspacePath")]
    public string? WorkspacePath { get; set; }
}

/// <summary>If specified, replaces the session's approved/denied permission rules. Omit to leave the current rules unchanged.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionRulesSet
{
    /// <summary>Rules that auto-approve matching requests.</summary>
    [JsonPropertyName("approved")]
    public IList<PermissionRule> Approved { get => field ??= []; set; }

    /// <summary>Rules that auto-deny matching requests.</summary>
    [JsonPropertyName("denied")]
    public IList<PermissionRule> Denied { get => field ??= []; set; }
}

/// <summary>If specified, replaces the session's URL-permission policy. The runtime constructs a fresh DefaultUrlManager based on these inputs. Omit to leave the current URL policy unchanged.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionUrlsConfig
{
    /// <summary>Initial list of allowed URL/domain patterns. Patterns may include path components. Ignored when `unrestricted` is true.</summary>
    [JsonPropertyName("initialAllowed")]
    public IList<string>? InitialAllowed { get; set; }

    /// <summary>If true, the runtime allows access to all URLs without prompting. Initial allow-list is ignored when this is true.</summary>
    [JsonPropertyName("unrestricted")]
    public bool? Unrestricted { get; set; }
}

/// <summary>Patch of permission policy fields to apply (omit a field to leave it unchanged).</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsConfigureParams
{
    /// <summary>If specified, replaces the host-supplied GitHub Content Exclusion policies on the session (combined with natively-discovered policies when evaluating tool/file access). Omit to leave the current policies unchanged.</summary>
    [JsonPropertyName("additionalContentExclusionPolicies")]
    public IList<PermissionsConfigureAdditionalContentExclusionPolicy>? AdditionalContentExclusionPolicies { get; set; }

    /// <summary>If specified, sets whether path/URL read permission requests are auto-approved. Omit to leave the current value unchanged.</summary>
    [JsonPropertyName("approveAllReadPermissionRequests")]
    public bool? ApproveAllReadPermissionRequests { get; set; }

    /// <summary>If specified, sets whether tool permission requests are auto-approved without prompting. Omit to leave the current value unchanged.</summary>
    [JsonPropertyName("approveAllToolPermissionRequests")]
    public bool? ApproveAllToolPermissionRequests { get; set; }

    /// <summary>If specified, replaces the session's path-permission policy. The runtime constructs the appropriate PathManager based on these inputs (rooted at the session's working directory). Omit to leave the current path policy unchanged.</summary>
    [JsonPropertyName("paths")]
    public PermissionPathsConfig? Paths { get; set; }

    /// <summary>If specified, replaces the session's approved/denied permission rules. Omit to leave the current rules unchanged.</summary>
    [JsonPropertyName("rules")]
    public PermissionRulesSet? Rules { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>If specified, replaces the session's URL-permission policy. The runtime constructs a fresh DefaultUrlManager based on these inputs. Omit to leave the current URL policy unchanged.</summary>
    [JsonPropertyName("urls")]
    public PermissionUrlsConfig? Urls { get; set; }
}

/// <summary>Indicates whether the permission decision was applied; false when the request was already resolved.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionRequestResult
{
    /// <summary>Whether the permission request was handled successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>The client's response to the pending permission prompt.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PermissionDecisionApproveOnce), "approve-once")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSession), "approve-for-session")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocation), "approve-for-location")]
[JsonDerivedType(typeof(PermissionDecisionApprovePermanently), "approve-permanently")]
[JsonDerivedType(typeof(PermissionDecisionReject), "reject")]
[JsonDerivedType(typeof(PermissionDecisionUserNotAvailable), "user-not-available")]
[JsonDerivedType(typeof(PermissionDecisionApproved), "approved")]
[JsonDerivedType(typeof(PermissionDecisionApprovedForSession), "approved-for-session")]
[JsonDerivedType(typeof(PermissionDecisionApprovedForLocation), "approved-for-location")]
[JsonDerivedType(typeof(PermissionDecisionCancelled), "cancelled")]
[JsonDerivedType(typeof(PermissionDecisionDeniedByRules), "denied-by-rules")]
[JsonDerivedType(typeof(PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser), "denied-no-approval-rule-and-could-not-request-from-user")]
[JsonDerivedType(typeof(PermissionDecisionDeniedInteractivelyByUser), "denied-interactively-by-user")]
[JsonDerivedType(typeof(PermissionDecisionDeniedByContentExclusionPolicy), "denied-by-content-exclusion-policy")]
[JsonDerivedType(typeof(PermissionDecisionDeniedByPermissionRequestHook), "denied-by-permission-request-hook")]
public partial class PermissionDecision
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Permission-decision request variant to approve only the current permission request.</summary>
/// <remarks>The <c>approve-once</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveOnce : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approve-once";

    /// <summary>True only when a host surfaced this request to a user who approved it.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("approvedInteractively")]
    public bool? ApprovedInteractively { get; set; }
}

/// <summary>Session-scoped approval to remember (tool prompts only; omitted for path/url prompts).</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalCommands), "commands")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalRead), "read")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalWrite), "write")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalMcp), "mcp")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalMcpSampling), "mcp-sampling")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalMemory), "memory")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalCustomTool), "custom-tool")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalExtensionManagement), "extension-management")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalFactory), "factory")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalExtensionPermissionAccess), "extension-permission-access")]
[JsonDerivedType(typeof(PermissionDecisionApproveForSessionApprovalExtensionEnvAccess), "extension-env-access")]
public partial class PermissionDecisionApproveForSessionApproval
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Session-scoped approval details for specific command identifiers.</summary>
/// <remarks>The <c>commands</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalCommands : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "commands";

    /// <summary>Command identifiers covered by this approval.</summary>
    [JsonPropertyName("commandIdentifiers")]
    public required IList<string> CommandIdentifiers { get; set; }
}

/// <summary>Session-scoped approval details for read-only filesystem operations.</summary>
/// <remarks>The <c>read</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalRead : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "read";
}

/// <summary>Session-scoped approval details for filesystem write operations.</summary>
/// <remarks>The <c>write</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalWrite : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "write";
}

/// <summary>Session-scoped approval details for an MCP server tool, or all tools on the server when `toolName` is null.</summary>
/// <remarks>The <c>mcp</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalMcp : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp";

    /// <summary>MCP server name.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>MCP tool name, or null to cover every tool on the server.</summary>
    [JsonPropertyName("toolName")]
    public string? ToolName { get; set; }
}

/// <summary>Session-scoped approval details for MCP sampling requests from a server.</summary>
/// <remarks>The <c>mcp-sampling</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalMcpSampling : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp-sampling";

    /// <summary>MCP server name.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Session-scoped approval details for writes to long-term memory.</summary>
/// <remarks>The <c>memory</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalMemory : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "memory";
}

/// <summary>Session-scoped approval details for a custom tool, keyed by tool name.</summary>
/// <remarks>The <c>custom-tool</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalCustomTool : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "custom-tool";

    /// <summary>Custom tool name.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Session-scoped approval details for extension-management operations, optionally narrowed by operation.</summary>
/// <remarks>The <c>extension-management</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalExtensionManagement : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-management";

    /// <summary>Optional operation identifier; when omitted, the approval covers all extension management operations.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("operation")]
    public string? Operation { get; set; }
}

/// <summary>Session-scoped factory approval, optionally narrowed by approval key.</summary>
/// <remarks>The <c>factory</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalFactory : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "factory";

    /// <summary>Optional factory operation name or canonical approval key; when omitted, the approval covers all factory operations.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("approvalKey")]
    public string? ApprovalKey { get; set; }
}

/// <summary>Session-scoped approval details for an extension's permission-gated capability access, keyed by extension name.</summary>
/// <remarks>The <c>extension-permission-access</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalExtensionPermissionAccess : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-permission-access";

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>Session-scoped approval details for an extension's access to sensitive environment variables, keyed by extension name and the exact set of variable names.</summary>
/// <remarks>The <c>extension-env-access</c> variant of <see cref="PermissionDecisionApproveForSessionApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSessionApprovalExtensionEnvAccess : PermissionDecisionApproveForSessionApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-env-access";

    /// <summary>Names of the sensitive environment variables this approval covers. Values are never persisted.</summary>
    [JsonPropertyName("environmentVariables")]
    public required IList<string> EnvironmentVariables { get; set; }

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>Permission-decision request variant to approve for the rest of the session, with optional tool approval or URL domain.</summary>
/// <remarks>The <c>approve-for-session</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForSession : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approve-for-session";

    /// <summary>Session-scoped approval to remember (tool prompts only; omitted for path/url prompts).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("approval")]
    public PermissionDecisionApproveForSessionApproval? Approval { get; set; }

    /// <summary>URL domain to approve for the rest of the session (URL prompts only).</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("domain")]
    public string? Domain { get; set; }
}

/// <summary>Approval to persist for this location.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalCommands), "commands")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalRead), "read")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalWrite), "write")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalMcp), "mcp")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalMcpSampling), "mcp-sampling")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalMemory), "memory")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalCustomTool), "custom-tool")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalExtensionManagement), "extension-management")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalFactory), "factory")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalExtensionPermissionAccess), "extension-permission-access")]
[JsonDerivedType(typeof(PermissionDecisionApproveForLocationApprovalExtensionEnvAccess), "extension-env-access")]
public partial class PermissionDecisionApproveForLocationApproval
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Location-scoped approval details for specific command identifiers.</summary>
/// <remarks>The <c>commands</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalCommands : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "commands";

    /// <summary>Command identifiers covered by this approval.</summary>
    [JsonPropertyName("commandIdentifiers")]
    public required IList<string> CommandIdentifiers { get; set; }
}

/// <summary>Location-scoped approval details for read-only filesystem operations.</summary>
/// <remarks>The <c>read</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalRead : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "read";
}

/// <summary>Location-scoped approval details for filesystem write operations.</summary>
/// <remarks>The <c>write</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalWrite : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "write";
}

/// <summary>Location-scoped approval details for an MCP server tool, or all tools on the server when `toolName` is null.</summary>
/// <remarks>The <c>mcp</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalMcp : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp";

    /// <summary>MCP server name.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>MCP tool name, or null to cover every tool on the server.</summary>
    [JsonPropertyName("toolName")]
    public string? ToolName { get; set; }
}

/// <summary>Location-scoped approval details for MCP sampling requests from a server.</summary>
/// <remarks>The <c>mcp-sampling</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalMcpSampling : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp-sampling";

    /// <summary>MCP server name.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Location-scoped approval details for writes to long-term memory.</summary>
/// <remarks>The <c>memory</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalMemory : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "memory";
}

/// <summary>Location-scoped approval details for a custom tool, keyed by tool name.</summary>
/// <remarks>The <c>custom-tool</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalCustomTool : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "custom-tool";

    /// <summary>Custom tool name.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Location-scoped approval details for extension-management operations, optionally narrowed by operation.</summary>
/// <remarks>The <c>extension-management</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalExtensionManagement : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-management";

    /// <summary>Optional operation identifier; when omitted, the approval covers all extension management operations.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("operation")]
    public string? Operation { get; set; }
}

/// <summary>Location-scoped factory approval, optionally narrowed by approval key.</summary>
/// <remarks>The <c>factory</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalFactory : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "factory";

    /// <summary>Optional factory operation name or canonical approval key; when omitted, the approval covers all factory operations.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("approvalKey")]
    public string? ApprovalKey { get; set; }
}

/// <summary>Location-scoped approval details for an extension's permission-gated capability access, keyed by extension name.</summary>
/// <remarks>The <c>extension-permission-access</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalExtensionPermissionAccess : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-permission-access";

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>Location-scoped approval details for an extension's access to sensitive environment variables, keyed by extension name and the exact set of variable names.</summary>
/// <remarks>The <c>extension-env-access</c> variant of <see cref="PermissionDecisionApproveForLocationApproval"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocationApprovalExtensionEnvAccess : PermissionDecisionApproveForLocationApproval
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-env-access";

    /// <summary>Names of the sensitive environment variables this approval covers. Values are never persisted.</summary>
    [JsonPropertyName("environmentVariables")]
    public required IList<string> EnvironmentVariables { get; set; }

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>Permission-decision request variant to approve and persist a permission for a project location, with approval details and location key.</summary>
/// <remarks>The <c>approve-for-location</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproveForLocation : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approve-for-location";

    /// <summary>Approval to persist for this location.</summary>
    [JsonPropertyName("approval")]
    public required PermissionDecisionApproveForLocationApproval Approval { get; set; }

    /// <summary>Location key (git root or cwd) to persist the approval to.</summary>
    [JsonPropertyName("locationKey")]
    public required string LocationKey { get; set; }
}

/// <summary>Permission-decision request variant to permanently approve a URL domain across sessions.</summary>
/// <remarks>The <c>approve-permanently</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApprovePermanently : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approve-permanently";

    /// <summary>URL domain to approve permanently.</summary>
    [JsonPropertyName("domain")]
    public required string Domain { get; set; }
}

/// <summary>Permission-decision request variant to reject a pending permission request, with optional feedback.</summary>
/// <remarks>The <c>reject</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionReject : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "reject";

    /// <summary>Optional feedback explaining the rejection.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("feedback")]
    public string? Feedback { get; set; }
}

/// <summary>Permission-decision variant indicating no user was available to confirm the request.</summary>
/// <remarks>The <c>user-not-available</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionUserNotAvailable : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "user-not-available";
}

/// <summary>Permission-decision variant indicating the request was approved.</summary>
/// <remarks>The <c>approved</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApproved : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approved";
}

/// <summary>Permission-decision variant indicating approval was remembered for the session, with approval details.</summary>
/// <remarks>The <c>approved-for-session</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApprovedForSession : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approved-for-session";

    /// <summary>The approval to add as a session-scoped rule.</summary>
    [JsonPropertyName("approval")]
    public required UserToolSessionApproval Approval { get; set; }
}

/// <summary>Permission-decision variant indicating approval was persisted for a project location, with approval details and location key.</summary>
/// <remarks>The <c>approved-for-location</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionApprovedForLocation : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "approved-for-location";

    /// <summary>The approval to persist for this location.</summary>
    [JsonPropertyName("approval")]
    public required UserToolSessionApproval Approval { get; set; }

    /// <summary>The location key (git root or cwd) to persist the approval to.</summary>
    [JsonPropertyName("locationKey")]
    public required string LocationKey { get; set; }
}

/// <summary>Permission-decision variant indicating the request was cancelled before use, with an optional reason.</summary>
/// <remarks>The <c>cancelled</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionCancelled : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "cancelled";

    /// <summary>Optional explanation of why the request was cancelled.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("reason")]
    public string? Reason { get; set; }
}

/// <summary>Permission-decision variant indicating explicit denial by permission rules, with the matching rules.</summary>
/// <remarks>The <c>denied-by-rules</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionDeniedByRules : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-by-rules";

    /// <summary>Rules that denied the request.</summary>
    [JsonPropertyName("rules")]
    public required IList<PermissionRule> Rules { get; set; }
}

/// <summary>Permission-decision variant indicating no approval rule matched and user confirmation was unavailable.</summary>
/// <remarks>The <c>denied-no-approval-rule-and-could-not-request-from-user</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-no-approval-rule-and-could-not-request-from-user";
}

/// <summary>Permission-decision variant indicating the user denied an interactive prompt, with optional feedback and force-reject flag.</summary>
/// <remarks>The <c>denied-interactively-by-user</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionDeniedInteractivelyByUser : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-interactively-by-user";

    /// <summary>Optional feedback from the user explaining the denial.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("feedback")]
    public string? Feedback { get; set; }

    /// <summary>Whether to force-reject the current agent turn.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("forceReject")]
    public bool? ForceReject { get; set; }
}

/// <summary>Permission-decision variant indicating denial by content-exclusion policy, with path and message.</summary>
/// <remarks>The <c>denied-by-content-exclusion-policy</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionDeniedByContentExclusionPolicy : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-by-content-exclusion-policy";

    /// <summary>Human-readable explanation of why the path was excluded.</summary>
    [JsonPropertyName("message")]
    public required string Message { get; set; }

    /// <summary>File path that triggered the exclusion.</summary>
    [JsonPropertyName("path")]
    public required string Path { get; set; }
}

/// <summary>Permission-decision variant indicating denial by a permission request hook, with optional message and interrupt flag.</summary>
/// <remarks>The <c>denied-by-permission-request-hook</c> variant of <see cref="PermissionDecision"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionDecisionDeniedByPermissionRequestHook : PermissionDecision
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "denied-by-permission-request-hook";

    /// <summary>Whether to interrupt the current agent turn.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("interrupt")]
    public bool? Interrupt { get; set; }

    /// <summary>Optional message from the hook explaining the denial.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("message")]
    public string? Message { get; set; }
}

/// <summary>Pending permission request ID and the decision to apply (approve/reject and scope).</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionDecisionRequest
{
    /// <summary>Optional informational context describing how and where this response was made. Omit it to preserve legacy behavior without attributing an origin.</summary>
    [JsonPropertyName("decisionContext")]
    public PermissionDecisionContext? DecisionContext { get; set; }

    /// <summary>Request ID of the pending permission request.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>The client's response to the pending permission prompt.</summary>
    [JsonPropertyName("result")]
    public PermissionDecision Result { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Pending permission prompt reconstructed from event history, with request ID and user-facing prompt details.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PendingPermissionRequest
{
    /// <summary>The user-facing permission prompt details (commands, write, read, mcp, url, memory, custom-tool, path, hook).</summary>
    [JsonPropertyName("request")]
    public PermissionPromptRequest Request { get; set; } = null!;

    /// <summary>Unique identifier for the pending permission request.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;
}

/// <summary>List of pending permission requests reconstructed from event history.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PendingPermissionRequestList
{
    /// <summary>Pending permission prompts reconstructed from the session's event history. Equivalent to the set of `permission.requested` events that have not yet been followed by a matching `permission.completed` event. Used by clients (e.g. the CLI) to hydrate UI for prompts that were emitted before the client attached to the session.</summary>
    [JsonPropertyName("items")]
    public IList<PendingPermissionRequest> Items { get => field ??= []; set; }
}

/// <summary>No parameters; returns currently-pending permission requests for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsPendingRequestsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsSetApproveAllResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Allow-all toggle for tool permission requests, with an optional telemetry source.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsSetApproveAllRequest
{
    /// <summary>Whether to auto-approve all tool permission requests.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional source for allow-all telemetry. Defaults to `rpc` when omitted for SDK callers.</summary>
    [JsonPropertyName("source")]
    public PermissionsSetApproveAllSource? Source { get; set; }
}

/// <summary>Indicates whether the requested permission mode was applied and reports the authoritative post-mutation mode.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsSetModeResult
{
    /// <summary>Authoritative permission mode after the mutation.</summary>
    [JsonPropertyName("mode")]
    public PermissionMode Mode { get; set; }

    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Permission mode to apply for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsSetModeRequest
{
    /// <summary>Optional judge model id for assisted mode. When omitted, the session resolves the provider default: `gpt-5.5` for CAPI sessions and the active session model for BYOK sessions.</summary>
    [JsonPropertyName("assistedApprovalModel")]
    public string? AssistedApprovalModel { get; set; }

    /// <summary>Permission mode to apply.</summary>
    [JsonPropertyName("mode")]
    public PermissionMode Mode { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Optional source for permission-mode telemetry. Defaults to `rpc` when omitted for SDK callers.</summary>
    [JsonPropertyName("source")]
    public PermissionModeSource? Source { get; set; }
}

/// <summary>Current permission mode.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsGetModeResult
{
    /// <summary>Current permission mode.</summary>
    [JsonPropertyName("mode")]
    public PermissionMode Mode { get; set; }
}

/// <summary>No parameters.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsGetModeRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsModifyRulesResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Scope and add/remove instructions for modifying session- or location-scoped permission rules.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsModifyRulesParams
{
    /// <summary>Rules to add to the scope. Applied before `remove`/`removeAll`.</summary>
    [JsonPropertyName("add")]
    public IList<PermissionRule>? Add { get; set; }

    /// <summary>Specific rules to remove from the scope. Ignored when `removeAll` is true.</summary>
    [JsonPropertyName("remove")]
    public IList<PermissionRule>? Remove { get; set; }

    /// <summary>When true, removes every rule currently in the scope (after any `add` is applied). Useful for clearing the location scope wholesale.</summary>
    [JsonPropertyName("removeAll")]
    public bool? RemoveAll { get; set; }

    /// <summary>Whether the change applies to ephemeral session-scoped rules (cleared at session end) or to location-scoped rules persisted via the location-permissions config file.</summary>
    [JsonPropertyName("scope")]
    public PermissionsModifyRulesScope Scope { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsSetRequiredResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Toggles whether permission prompts should be bridged into session events for this client.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsSetRequiredRequest
{
    /// <summary>Whether the client wants `permission.requested` events bridged from the session-owned permission service. CLI clients that render prompt UI set this to `true` for as long as their listener is mounted; headless callers leave it unset (the default is `false`).</summary>
    [JsonPropertyName("required")]
    public bool Required { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsResetSessionApprovalsResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Clears session-scoped tool permission approvals, and optionally the location-scoped ones.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsResetSessionApprovalsRequest
{
    /// <summary>Whether location-scoped approvals are cleared too. Defaults to `true`.</summary>
    [JsonPropertyName("includeLocation")]
    public bool? IncludeLocation { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsNotifyPromptShownResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Notification payload describing the permission prompt that the client just rendered.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionPromptShownNotification
{
    /// <summary>Human-readable description of the prompt the user is being asked to approve. Used by the runtime to fire the registered `permission_prompt` notification hook (e.g. terminal bell, desktop notification).</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Snapshot of the session's allow-listed directories and primary working directory.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionPathsList
{
    /// <summary>All directories currently allowed for tool access on this session.</summary>
    [JsonPropertyName("directories")]
    public IList<string> Directories { get => field ??= []; set; }

    /// <summary>The primary working directory for this session.</summary>
    [JsonPropertyName("primary")]
    public string Primary { get; set; } = string.Empty;
}

/// <summary>No parameters; returns the session's allow-listed directories.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionsPathsListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsPathsAddResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Directory path to add to the session's allowed directories.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionPathsAddParams
{
    /// <summary>Directory to add to the allow-list. The runtime resolves and validates the path before adding, then loads conventional `.github/skills/` and `.github/agents/` definitions under it when their subsystem gates are enabled. Adding the directory is therefore also a trust decision for configuration stored there.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsPathsUpdatePrimaryResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Directory path to set as the session's new primary working directory.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionPathsUpdatePrimaryParams
{
    /// <summary>Directory to set as the new primary working directory for the session's permission policy.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the supplied path is within the session's allowed directories.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionPathsAllowedCheckResult
{
    /// <summary>Whether the path is within the session's allowed directories.</summary>
    [JsonPropertyName("allowed")]
    public bool Allowed { get; set; }
}

/// <summary>Path to evaluate against the session's allowed directories.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionPathsAllowedCheckParams
{
    /// <summary>Path to check against the session's allowed directories.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the supplied path is within the session's workspace directory.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionPathsWorkspaceCheckResult
{
    /// <summary>Whether the path is within the session workspace directory.</summary>
    [JsonPropertyName("allowed")]
    public bool Allowed { get; set; }
}

/// <summary>Path to evaluate against the session's workspace (primary) directory.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionPathsWorkspaceCheckParams
{
    /// <summary>Path to check against the session workspace directory.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Resolved location-permissions key and type.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionLocationResolveResult
{
    /// <summary>Location key used in the location-permissions store.</summary>
    [JsonPropertyName("locationKey")]
    public string LocationKey { get; set; } = string.Empty;

    /// <summary>Whether the location is a git repo or directory.</summary>
    [JsonPropertyName("locationType")]
    public PermissionLocationType LocationType { get; set; }
}

/// <summary>Working directory to resolve into a location-permissions key.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionLocationResolveParams
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Working directory whose permission location should be resolved.</summary>
    [JsonPropertyName("workingDirectory")]
    public string WorkingDirectory { get; set; } = string.Empty;
}

/// <summary>Summary of persisted location permissions applied to the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionLocationApplyResult
{
    /// <summary>Number of persisted allowed directories added to the live path manager.</summary>
    [JsonPropertyName("appliedDirectoryCount")]
    public long AppliedDirectoryCount { get; set; }

    /// <summary>Number of location-scoped rules added to the live permission service.</summary>
    [JsonPropertyName("appliedRuleCount")]
    public long AppliedRuleCount { get; set; }

    /// <summary>Location-scoped rules applied to the live permission service.</summary>
    [JsonPropertyName("appliedRules")]
    public IList<PermissionRule> AppliedRules { get => field ??= []; set; }

    /// <summary>Whether a different location was applied since the previous apply call.</summary>
    [JsonPropertyName("changed")]
    public bool Changed { get; set; }

    /// <summary>Location key used in the location-permissions store.</summary>
    [JsonPropertyName("locationKey")]
    public string LocationKey { get; set; } = string.Empty;

    /// <summary>Whether the location is a git repo or directory.</summary>
    [JsonPropertyName("locationType")]
    public PermissionLocationType LocationType { get; set; }
}

/// <summary>Working directory to load persisted location permissions for.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionLocationApplyParams
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Working directory whose persisted location permissions should be applied.</summary>
    [JsonPropertyName("workingDirectory")]
    public string WorkingDirectory { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsLocationsAddToolApprovalResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Tool approval to persist and apply.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsCommands), "commands")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsRead), "read")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsWrite), "write")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsMcp), "mcp")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsMcpSampling), "mcp-sampling")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsMemory), "memory")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsCustomTool), "custom-tool")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsExtensionManagement), "extension-management")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsFactory), "factory")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsExtensionPermissionAccess), "extension-permission-access")]
[JsonDerivedType(typeof(PermissionsLocationsAddToolApprovalDetailsExtensionEnvAccess), "extension-env-access")]
public partial class PermissionsLocationsAddToolApprovalDetails
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Location-persisted tool approval details for specific command identifiers.</summary>
/// <remarks>The <c>commands</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsCommands : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "commands";

    /// <summary>Command identifiers covered by this approval.</summary>
    [JsonPropertyName("commandIdentifiers")]
    public required IList<string> CommandIdentifiers { get; set; }
}

/// <summary>Location-persisted tool approval details for read-only filesystem operations.</summary>
/// <remarks>The <c>read</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsRead : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "read";
}

/// <summary>Location-persisted tool approval details for filesystem write operations.</summary>
/// <remarks>The <c>write</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsWrite : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "write";
}

/// <summary>Location-persisted tool approval details for an MCP server tool, or all tools when `toolName` is null.</summary>
/// <remarks>The <c>mcp</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsMcp : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp";

    /// <summary>MCP server name.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }

    /// <summary>MCP tool name, or null to cover every tool on the server.</summary>
    [JsonPropertyName("toolName")]
    public string? ToolName { get; set; }
}

/// <summary>Location-persisted tool approval details for MCP sampling requests from a server.</summary>
/// <remarks>The <c>mcp-sampling</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsMcpSampling : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "mcp-sampling";

    /// <summary>MCP server name.</summary>
    [JsonPropertyName("serverName")]
    public required string ServerName { get; set; }
}

/// <summary>Location-persisted tool approval details for writes to long-term memory.</summary>
/// <remarks>The <c>memory</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsMemory : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "memory";
}

/// <summary>Location-persisted tool approval details for a custom tool, keyed by tool name.</summary>
/// <remarks>The <c>custom-tool</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsCustomTool : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "custom-tool";

    /// <summary>Custom tool name.</summary>
    [JsonPropertyName("toolName")]
    public required string ToolName { get; set; }
}

/// <summary>Location-persisted tool approval details for extension-management operations, optionally narrowed by operation.</summary>
/// <remarks>The <c>extension-management</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsExtensionManagement : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-management";

    /// <summary>Optional operation identifier; when omitted, the approval covers all extension management operations.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("operation")]
    public string? Operation { get; set; }
}

/// <summary>Location-persisted factory approval, optionally narrowed by approval key.</summary>
/// <remarks>The <c>factory</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsFactory : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "factory";

    /// <summary>Optional factory operation name or canonical approval key; when omitted, the approval covers all factory operations.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("approvalKey")]
    public string? ApprovalKey { get; set; }
}

/// <summary>Location-persisted tool approval details for an extension's permission-gated capability access, keyed by extension name.</summary>
/// <remarks>The <c>extension-permission-access</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsExtensionPermissionAccess : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-permission-access";

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>Location-persisted tool approval details for an extension's access to sensitive environment variables, keyed by extension name and the exact set of variable names.</summary>
/// <remarks>The <c>extension-env-access</c> variant of <see cref="PermissionsLocationsAddToolApprovalDetails"/>.</remarks>
[Experimental(Diagnostics.Experimental)]
public partial class PermissionsLocationsAddToolApprovalDetailsExtensionEnvAccess : PermissionsLocationsAddToolApprovalDetails
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "extension-env-access";

    /// <summary>Names of the sensitive environment variables this approval covers. Values are never persisted.</summary>
    [JsonPropertyName("environmentVariables")]
    public required IList<string> EnvironmentVariables { get; set; }

    /// <summary>Extension name.</summary>
    [JsonPropertyName("extensionName")]
    public required string ExtensionName { get; set; }
}

/// <summary>Location-scoped tool approval to persist.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionLocationAddToolApprovalParams
{
    /// <summary>Tool approval to persist and apply.</summary>
    [JsonPropertyName("approval")]
    public PermissionsLocationsAddToolApprovalDetails Approval { get => field ??= new(); set; }

    /// <summary>Location key (git root or cwd) to persist the approval to.</summary>
    [JsonPropertyName("locationKey")]
    public string LocationKey { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Folder trust check result.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FolderTrustCheckResult
{
    /// <summary>Whether the folder is trusted.</summary>
    [JsonPropertyName("trusted")]
    public bool Trusted { get; set; }
}

/// <summary>Folder path to check for trust.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FolderTrustCheckParams
{
    /// <summary>Folder path to check.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsFolderTrustAddTrustedResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Folder path to add to trusted folders.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class FolderTrustAddParams
{
    /// <summary>Folder path to mark as trusted.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsUrlsSetUnrestrictedModeResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Whether the URL-permission policy should run in unrestricted mode.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class PermissionUrlsSetUnrestrictedModeParams
{
    /// <summary>Whether to allow access to all URLs without prompting. Toggles the runtime's URL-permission policy in place.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The repository the remote session targets.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataSnapshotRemoteMetadataRepository
{
    /// <summary>The branch the remote session is operating on.</summary>
    [JsonPropertyName("branch")]
    public string Branch { get; set; } = string.Empty;

    /// <summary>The GitHub repository name (without owner).</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>The GitHub owner (user or organization) of the target repository.</summary>
    [JsonPropertyName("owner")]
    public string Owner { get; set; } = string.Empty;
}

/// <summary>Remote-session-specific metadata. Populated only when `isRemote` is true. Fields are immutable for the lifetime of the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataSnapshotRemoteMetadata
{
    /// <summary>The pull request number the remote session is associated with, if any.</summary>
    [JsonPropertyName("pullRequestNumber")]
    public long? PullRequestNumber { get; set; }

    /// <summary>The repository the remote session targets.</summary>
    [JsonPropertyName("repository")]
    public MetadataSnapshotRemoteMetadataRepository Repository { get => field ??= new(); set; }

    /// <summary>The original resource identifier (task ID or PR node ID), preserved across event-replay reconstructions. Falls back to `sessionId` when absent.</summary>
    [JsonPropertyName("resourceId")]
    public string? ResourceId { get; set; }

    /// <summary>Whether the remote task originated from Copilot Coding Agent (cca) or a CLI `--remote` invocation.</summary>
    [JsonPropertyName("taskType")]
    public MetadataSnapshotRemoteMetadataTaskType? TaskType { get; set; }
}

/// <summary>Public-facing projection of workspace metadata for SDK / TUI consumers.</summary>
public sealed class SessionMetadataSnapshotWorkspace
{
    /// <summary>Branch checked out at session start, if any.</summary>
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>ISO 8601 timestamp when the workspace was created.</summary>
    [JsonPropertyName("created_at")]
    public DateTimeOffset? CreatedAt { get; set; }

    /// <summary>Current working directory at session start.</summary>
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Resolved git root for cwd, if any.</summary>
    [JsonPropertyName("git_root")]
    public string? GitRoot { get; set; }

    /// <summary>Repository host type, if known.</summary>
    [JsonPropertyName("host_type")]
    public WorkspaceSummaryHostType? HostType { get; set; }

    /// <summary>Workspace identifier (1:1 with sessionId).</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Display name for the session, if set.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>Repository identifier in 'owner/repo' or 'org/project/repo' format, if any.</summary>
    [JsonPropertyName("repository")]
    public string? Repository { get; set; }

    /// <summary>ISO 8601 timestamp when the workspace was last updated.</summary>
    [JsonPropertyName("updated_at")]
    public DateTimeOffset? UpdatedAt { get; set; }

    /// <summary>Whether the display name was explicitly set by the user.</summary>
    [JsonPropertyName("user_named")]
    public bool? UserNamed { get; set; }
}

/// <summary>Point-in-time snapshot of slow-changing session identifier and state fields.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionMetadataSnapshot
{
    /// <summary>True when the session was detected to be in use by another process at construction time. Local consumers may surface a confirmation prompt before fully attaching. Always false for new sessions.</summary>
    [JsonPropertyName("alreadyInUse")]
    public bool AlreadyInUse { get; set; }

    /// <summary>Runtime client name associated with the session (telemetry identifier).</summary>
    [JsonPropertyName("clientName")]
    public string? ClientName { get; set; }

    /// <summary>The current agent mode for this session (e.g., 'interactive', 'plan', 'autopilot').</summary>
    [JsonPropertyName("currentMode")]
    public MetadataSnapshotCurrentMode CurrentMode { get; set; }

    /// <summary>User-provided name supplied at session construction (via `--name`), if any. Immutable after construction.</summary>
    [JsonPropertyName("initialName")]
    public string? InitialName { get; set; }

    /// <summary>Whether this is a remote session (i.e., one whose runtime executes elsewhere and is steered through this process).</summary>
    [JsonPropertyName("isRemote")]
    public bool IsRemote { get; set; }

    /// <summary>ISO 8601 timestamp of when the session's persisted state was last modified on disk. For new sessions, equals startTime. For resumed sessions, reflects the previous modification time at construction.</summary>
    [JsonPropertyName("modifiedTime")]
    public DateTimeOffset ModifiedTime { get; set; }

    /// <summary>Remote-session-specific metadata. Populated only when `isRemote` is true. Fields are immutable for the lifetime of the session.</summary>
    [JsonPropertyName("remoteMetadata")]
    public MetadataSnapshotRemoteMetadata? RemoteMetadata { get; set; }

    /// <summary>Currently selected model identifier, if any.</summary>
    [JsonPropertyName("selectedModel")]
    public string? SelectedModel { get; set; }

    /// <summary>The unique identifier of the session.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Current session limits, or null when no limits are active.</summary>
    [JsonPropertyName("sessionLimits")]
    public SessionLimitsConfig? SessionLimits { get; set; }

    /// <summary>ISO 8601 timestamp of when the session started.</summary>
    [JsonPropertyName("startTime")]
    public DateTimeOffset StartTime { get; set; }

    /// <summary>Short human-readable summary of the session, if known. Omitted when no summary has been generated.</summary>
    [JsonPropertyName("summary")]
    public string? Summary { get; set; }

    /// <summary>Absolute path to the session's current working directory.</summary>
    [JsonPropertyName("workingDirectory")]
    public string WorkingDirectory { get; set; } = string.Empty;

    /// <summary>Public-facing workspace metadata for this session, or null if the session has no associated workspace. Excludes runtime-internal fields (GitHub IDs, summary count, internal flags).</summary>
    [JsonPropertyName("workspace")]
    public SessionMetadataSnapshotWorkspace? Workspace { get; set; }

    /// <summary>Absolute path to the session's workspace directory on disk, or null if the session has no associated workspace.</summary>
    [JsonPropertyName("workspacePath")]
    public string? WorkspacePath { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMetadataSnapshotRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMetadataGetClientMetadataRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Atomic patch for client-owned session metadata. Operations apply in clear, remove, then set order. The resulting bag must satisfy the ClientMetadata entry and serialized-size limits. Local storage coordinates concurrent runtime processes; custom SessionFs providers must serialize writers that access the same session from multiple processes.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class MetadataUpdateClientMetadataRequest
{
    /// <summary>Remove every existing client metadata entry before applying remove and set. Defaults to false.</summary>
    [JsonPropertyName("clear")]
    public bool? Clear { get; set; }

    /// <summary>Case-sensitive keys to remove. Missing keys are ignored. Each key must be non-empty, at most 256 UTF-8 bytes, and outside the reserved `copilot/` and `github/` namespaces.</summary>
    [JsonPropertyName("remove")]
    public IList<string>? Remove { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>String entries to add or replace. Set wins when a key also appears in remove. Each key must be non-empty, at most 256 UTF-8 bytes, and outside the reserved `copilot/` and `github/` namespaces. Each value may contain at most 16 KiB of UTF-8 data.</summary>
    [JsonPropertyName("set")]
    public IDictionary<string, string>? Set { get; set; }
}

/// <summary>Indicates whether the local session is currently processing a turn or background continuation.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataIsProcessingResult
{
    /// <summary>Whether the session is currently processing user/agent messages. False for non-local sessions (which don't run a local agentic loop). Reflects an in-flight turn or background continuation.</summary>
    [JsonPropertyName("processing")]
    public bool Processing { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMetadataIsProcessingRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Current activity flags for the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionActivity
{
    /// <summary>Whether an in-flight operation can currently be aborted.</summary>
    [JsonPropertyName("abortable")]
    public bool Abortable { get; set; }

    /// <summary>Whether the session currently has active work, including running turns or tasks.</summary>
    [JsonPropertyName("hasActiveWork")]
    public bool HasActiveWork { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMetadataActivityRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Token-usage breakdown for the session's current context window.</summary>
public sealed class MetadataContextInfoResultContextInfo
{
    /// <summary>Output reserve plus tokens after the buffer-exhaustion blocking threshold (default 95%).</summary>
    [JsonPropertyName("bufferTokens")]
    public long BufferTokens { get; set; }

    /// <summary>Token count at which background compaction starts (configurable percentage of promptTokenLimit).</summary>
    [JsonPropertyName("compactionThreshold")]
    public long CompactionThreshold { get; set; }

    /// <summary>Tokens consumed by user/assistant/tool messages.</summary>
    [JsonPropertyName("conversationTokens")]
    public long ConversationTokens { get; set; }

    /// <summary>Prompt token limit plus the model's full output token limit.</summary>
    [JsonPropertyName("limit")]
    public long Limit { get; set; }

    /// <summary>Tokens consumed by MCP tool definitions (subset of toolDefinitionsTokens, excludes deferred tools).</summary>
    [JsonPropertyName("mcpToolsTokens")]
    public long McpToolsTokens { get; set; }

    /// <summary>The model used for token counting.</summary>
    [JsonPropertyName("modelName")]
    public string ModelName { get; set; } = string.Empty;

    /// <summary>Maximum prompt tokens allowed by the model (or DEFAULT_TOKEN_LIMIT if unspecified).</summary>
    [JsonPropertyName("promptTokenLimit")]
    public long PromptTokenLimit { get; set; }

    /// <summary>Tokens consumed by the system prompt.</summary>
    [JsonPropertyName("systemTokens")]
    public long SystemTokens { get; set; }

    /// <summary>Tokens consumed by tool definitions sent to the model (excludes deferred tools).</summary>
    [JsonPropertyName("toolDefinitionsTokens")]
    public long ToolDefinitionsTokens { get; set; }

    /// <summary>Sum of system, conversation and tool-definition tokens.</summary>
    [JsonPropertyName("totalTokens")]
    public long TotalTokens { get; set; }
}

/// <summary>Token breakdown for the session's current context window, or null if uninitialized.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataContextInfoResult
{
    /// <summary>Token breakdown for the current context window, or null if the session has not yet been initialized (no system prompt or tool metadata cached).</summary>
    [JsonPropertyName("contextInfo")]
    public MetadataContextInfoResultContextInfo? ContextInfo { get; set; }
}

/// <summary>Model identifier and token limits used to compute the context-info breakdown.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class MetadataContextInfoRequest
{
    /// <summary>Maximum output tokens allowed by the target model. Pass 0 if unknown.</summary>
    [JsonPropertyName("outputTokenLimit")]
    public long OutputTokenLimit { get; set; }

    /// <summary>Maximum prompt tokens allowed by the target model. Pass 0 to use the runtime default.</summary>
    [JsonPropertyName("promptTokenLimit")]
    public long PromptTokenLimit { get; set; }

    /// <summary>Model identifier used for tokenization. Omit to use the session default. Used both for token counting and to compute display values.</summary>
    [JsonPropertyName("selectedModel")]
    public string? SelectedModel { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>The six normalized `/context` header buckets, computed from the same tokenization as `entries` so the two never disagree. Convenience rollups: `freeSpace` and `buffer` describe window capacity rather than occupied context, so the values do not sum to `totalTokens`.</summary>
public sealed class MetadataContextAttributionResultContextAttributionCategories
{
    /// <summary>Output reserve plus post-blocking-threshold buffer.</summary>
    [JsonPropertyName("buffer")]
    public long Buffer { get; set; }

    /// <summary>Custom-instructions tokens (0 when none are configured).</summary>
    [JsonPropertyName("customInstructions")]
    public long CustomInstructions { get; set; }

    /// <summary>Remaining unused window capacity (clamped at 0).</summary>
    [JsonPropertyName("freeSpace")]
    public long FreeSpace { get; set; }

    /// <summary>MCP tool-definition tokens.</summary>
    [JsonPropertyName("mcpTools")]
    public long McpTools { get; set; }

    /// <summary>Conversation (user/assistant/tool) message tokens.</summary>
    [JsonPropertyName("messages")]
    public long Messages { get; set; }

    /// <summary>System prompt tokens, excluding custom instructions.</summary>
    [JsonPropertyName("systemPrompt")]
    public long SystemPrompt { get; set; }

    /// <summary>Non-MCP tool-definition tokens.</summary>
    [JsonPropertyName("systemTools")]
    public long SystemTools { get; set; }
}

/// <summary>Successful compaction history for the session.</summary>
public sealed class MetadataContextAttributionResultContextAttributionCompactions
{
    /// <summary>Number of successful compactions in this session.</summary>
    [JsonPropertyName("count")]
    public long Count { get; set; }
}

/// <summary>RPC data type for MetadataContextAttributionResultContextAttributionEntry operations.</summary>
public sealed class MetadataContextAttributionResultContextAttributionEntry
{
    /// <summary>Supplementary per-entry metadata (e.g. `messageCount`, `role`, `evictable`, `pluginSource`). Values are stringified; parse as needed and ignore unrecognized keys.</summary>
    [JsonPropertyName("attributes")]
    public IDictionary<string, string>? Attributes { get; set; }

    /// <summary>Identifier for this entry, formed by joining its `kind` and source name (e.g. `tool:bash`, `skill:tmux`, `toolDefinition:bash`); unique within the snapshot. Use it to match the same entry across snapshots, to correlate with other APIs (skill/agent/MCP registries), and as the `parentId` target for nesting. Distinct from the human-facing `label`.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Source category for this entry. Not a closed set — tolerate unknown values. Known values today: `skill`, `subagent`, `mcpServer`, `tool`, `system`, `toolDefinition`, `plugin`.</summary>
    [JsonPropertyName("kind")]
    public string Kind { get; set; } = string.Empty;

    /// <summary>Human-readable display label, e.g. `bash` or `skill: tmux`. Presentation-only; may be localized/reformatted without notice — do not key off it.</summary>
    [JsonPropertyName("label")]
    public string Label { get; set; } = string.Empty;

    /// <summary>Optional `id` of the parent entry: e.g. a `plugin` entry parenting its `skill`/`mcpServer` entries, or the `system` entry parenting `toolDefinition` entries. Omitted for top-level entries.</summary>
    [JsonPropertyName("parentId")]
    public string? ParentId { get; set; }

    /// <summary>Token count currently in context attributable to this entry.</summary>
    [JsonPropertyName("tokens")]
    public long Tokens { get; set; }
}

/// <summary>Per-source token attribution snapshot for the current context window. The heaviest individual messages are available separately via `metadata.getContextHeaviestMessages`.</summary>
public sealed class MetadataContextAttributionResultContextAttribution
{
    /// <summary>Output reserve plus the tokens past the buffer-exhaustion blocking threshold. Mirrors `SessionContextInfo.bufferTokens`.</summary>
    [JsonPropertyName("bufferTokens")]
    public long BufferTokens { get; set; }

    /// <summary>The six normalized `/context` header buckets, computed from the same tokenization as `entries` so the two never disagree. Convenience rollups: `freeSpace` and `buffer` describe window capacity rather than occupied context, so the values do not sum to `totalTokens`.</summary>
    [JsonPropertyName("categories")]
    public MetadataContextAttributionResultContextAttributionCategories Categories { get => field ??= new(); set; }

    /// <summary>Successful compaction history for the session.</summary>
    [JsonPropertyName("compactions")]
    public MetadataContextAttributionResultContextAttributionCompactions Compactions { get => field ??= new(); set; }

    /// <summary>Token count at which background compaction starts. Mirrors `SessionContextInfo.compactionThreshold`.</summary>
    [JsonPropertyName("compactionThreshold")]
    public long CompactionThreshold { get; set; }

    /// <summary>Flat list of per-source attribution entries. Group by `kind` and render unrecognized kinds generically. Nesting and rollups are expressed via `parentId`.</summary>
    [JsonPropertyName("entries")]
    public IList<MetadataContextAttributionResultContextAttributionEntry> Entries { get => field ??= []; set; }

    /// <summary>Prompt limit plus the model's output reserve: the full context window `categories.freeSpace` and `categories.buffer` are measured against. Mirrors `SessionContextInfo.limit`.</summary>
    [JsonPropertyName("limit")]
    public long Limit { get; set; }

    /// <summary>The concrete model id the entire breakdown was tokenized against (feeds the per-model token multiplier). Under `Auto` (Free/Student) this is the resolved model, not the literal `auto` sentinel, so totals are not undercounted. A single-model approximation of a potentially multi-model Auto session.</summary>
    [JsonPropertyName("modelId")]
    public string ModelId { get; set; } = string.Empty;

    /// <summary>How `modelId` was chosen. Not a closed set — tolerate unknown values. Known values today: `autoResolved` (the model Auto resolved to), `selected` (the user's explicitly selected model), `default` (a fallback before any model is known).</summary>
    [JsonPropertyName("modelSource")]
    public string ModelSource { get; set; } = string.Empty;

    /// <summary>Maximum prompt tokens the resolved model accepts — the denominator for a `##k/###k` context-usage display. Mirrors `SessionContextInfo.promptTokenLimit`.</summary>
    [JsonPropertyName("promptTokenLimit")]
    public long PromptTokenLimit { get; set; }

    /// <summary>Total token count of the current context window the entries are measured against (system message + conversation messages + tool definitions — the same total reported by /context). Divide an entry's `tokens` by this to derive its share.</summary>
    [JsonPropertyName("totalTokens")]
    public long TotalTokens { get; set; }
}

/// <summary>Per-source attribution breakdown for the session's current context window, or null if uninitialized.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataContextAttributionResult
{
    /// <summary>Per-source context-window attribution, or null if the session has not yet been initialized (no system prompt or tool metadata cached).</summary>
    [JsonPropertyName("contextAttribution")]
    public MetadataContextAttributionResultContextAttribution? ContextAttribution { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionMetadataGetContextAttributionRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A single large message currently in context.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ContextHeaviestMessage
{
    /// <summary>Stable identifier for this message within the snapshot.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Human-readable source label, e.g. `tool: bash` or `skill: tmux`. Presentation-only.</summary>
    [JsonPropertyName("label")]
    public string Label { get; set; } = string.Empty;

    /// <summary>Role of the chat message (`user`, `assistant`, or `tool`).</summary>
    [JsonPropertyName("role")]
    public string Role { get; set; } = string.Empty;

    /// <summary>Token count currently in context for this individual message.</summary>
    [JsonPropertyName("tokens")]
    public long Tokens { get; set; }
}

/// <summary>The heaviest individual messages in the session's context window, most-expensive first.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataContextHeaviestMessagesResult
{
    /// <summary>Heaviest messages, most-expensive first.</summary>
    [JsonPropertyName("messages")]
    public IList<ContextHeaviestMessage> Messages { get => field ??= []; set; }

    /// <summary>Total token count of the current context window, so callers can compute each message's share without a second call.</summary>
    [JsonPropertyName("totalTokens")]
    public long TotalTokens { get; set; }
}

/// <summary>Parameters for the heaviest-messages query.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class MetadataContextHeaviestMessagesRequest
{
    /// <summary>Maximum number of messages to return, most-expensive first. Omit for the server default.</summary>
    [JsonPropertyName("limit")]
    public long? Limit { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode). For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event); move a local session's working directory via `metadata.setWorkingDirectory` instead.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataRecordContextChangeResult
{
}

/// <summary>Updated working directory and git context. Emitted as the new payload of `session.context_changed`.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionWorkingDirectoryContext
{
    /// <summary>Merge-base commit SHA (fork point from the remote default branch).</summary>
    [JsonPropertyName("baseCommit")]
    public string? BaseCommit { get; set; }

    /// <summary>Current git branch name.</summary>
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Current working directory path.</summary>
    [JsonPropertyName("cwd")]
    public string Cwd { get; set; } = string.Empty;

    /// <summary>Root directory of the git repository, resolved via git rev-parse.</summary>
    [JsonPropertyName("gitRoot")]
    public string? GitRoot { get; set; }

    /// <summary>Head commit of the current git branch.</summary>
    [JsonPropertyName("headCommit")]
    public string? HeadCommit { get; set; }

    /// <summary>Hosting platform type of the repository.</summary>
    [JsonPropertyName("hostType")]
    public SessionWorkingDirectoryContextHostType? HostType { get; set; }

    /// <summary>Repository identifier derived from the git remote URL ("owner/name" for GitHub, "org/project/repo" for Azure DevOps).</summary>
    [JsonPropertyName("repository")]
    public string? Repository { get; set; }

    /// <summary>Raw host string from the git remote URL (e.g. "github.com", "dev.azure.com").</summary>
    [JsonPropertyName("repositoryHost")]
    public string? RepositoryHost { get; set; }
}

/// <summary>Updated working-directory/git context to record on the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class MetadataRecordContextChangeRequest
{
    /// <summary>Updated working directory and git context. Emitted as the new payload of `session.context_changed`.</summary>
    [JsonPropertyName("context")]
    public SessionWorkingDirectoryContext Context { get => field ??= new(); set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Update the session's working directory. Used by the host when the user explicitly changes cwd (e.g., the `/cd` slash command). The host is responsible for any related side-effects (file index, etc.); it does NOT change the process working directory (a session's cwd is per-session, not process-global). For local sessions the runtime validates the target first (an absolute path that exists on disk) and re-bases the permission primary directory; a rejected validation fails the call before anything is mutated, persisted, or emitted. Location-scoped permission rules are then re-keyed to the new directory (best-effort). Remote sessions only record the path.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataSetWorkingDirectoryResult
{
    /// <summary>Working directory after the update.</summary>
    [JsonPropertyName("workingDirectory")]
    public string WorkingDirectory { get; set; } = string.Empty;
}

/// <summary>Absolute path to set as the session's new working directory. For local sessions the path must be absolute and exist on disk: it is validated before any session state changes, and a failing validation rejects the call with nothing mutated, persisted, or emitted. Remote sessions record the path as-is.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class MetadataSetWorkingDirectoryRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Absolute path to set as the session's working directory. The runtime updates the session's recorded cwd so subsequent operations (shell tools, file lookups, telemetry) anchor to it.</summary>
    [JsonPropertyName("workingDirectory")]
    public string WorkingDirectory { get; set; } = string.Empty;
}

/// <summary>Re-tokenize the session's existing messages against `modelId` and return the token totals. Useful for hosts that want an initial estimate of context usage on session resume, before the next agent turn fires `session.context_info_changed` events. Returns zeros for an empty session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataRecomputeContextTokensResult
{
    /// <summary>Tokens contributed by user/assistant/tool messages (excludes system/developer prompts).</summary>
    [JsonPropertyName("messagesTokenCount")]
    public long MessagesTokenCount { get; set; }

    /// <summary>Tokens contributed by system/developer prompt snapshots.</summary>
    [JsonPropertyName("systemTokenCount")]
    public long SystemTokenCount { get; set; }

    /// <summary>Sum of tokens across chat-context and system-context messages currently held by the session.</summary>
    [JsonPropertyName("totalTokens")]
    public long TotalTokens { get; set; }
}

/// <summary>Model identifier to use when re-tokenizing the session's existing messages.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class MetadataRecomputeContextTokensRequest
{
    /// <summary>Model identifier used for tokenization. The runtime token-counts both chat-context and system-context messages against this model.</summary>
    [JsonPropertyName("modelId")]
    public string ModelId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Availability of built-in job tools surfaced to boundary consumers.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSettingsBuiltInToolAvailabilitySnapshot
{
    /// <summary>Whether the create-pull-request tool is available.</summary>
    [JsonPropertyName("createPullRequest")]
    public bool? CreatePullRequest { get; set; }

    /// <summary>Whether the report-progress tool is available.</summary>
    [JsonPropertyName("reportProgress")]
    public bool? ReportProgress { get; set; }
}

/// <summary>Redacted job settings for a session. The job nonce is excluded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSettingsJobSnapshot
{
    /// <summary>Availability of job-specific built-in tools.</summary>
    [JsonPropertyName("builtInToolAvailability")]
    public SessionSettingsBuiltInToolAvailabilitySnapshot? BuiltInToolAvailability { get; set; }

    /// <summary>GitHub Actions event type for the job.</summary>
    [JsonPropertyName("eventType")]
    public string? EventType { get; set; }

    /// <summary>Whether this is the workflow's trigger job.</summary>
    [JsonPropertyName("isTriggerJob")]
    public bool? IsTriggerJob { get; set; }
}

/// <summary>Redacted model routing settings for a session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSettingsModelSnapshot
{
    /// <summary>Agent service callback URL for job and progress updates.</summary>
    [JsonPropertyName("callbackUrl")]
    public string? CallbackUrl { get; set; }

    /// <summary>Default reasoning effort for the selected model.</summary>
    [JsonPropertyName("defaultReasoningEffort")]
    public string? DefaultReasoningEffort { get; set; }

    /// <summary>Agent job identifier for the session.</summary>
    [JsonPropertyName("instanceId")]
    public string? InstanceId { get; set; }

    /// <summary>Selected model identifier.</summary>
    [JsonPropertyName("model")]
    public string? Model { get; set; }
}

/// <summary>Online-evaluation settings safe to expose across the SDK boundary.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSettingsOnlineEvaluationSnapshot
{
    /// <summary>Whether online evaluation is disabled.</summary>
    [JsonPropertyName("disableOnlineEvaluation")]
    public bool? DisableOnlineEvaluation { get; set; }

    /// <summary>Whether online-evaluation output-file generation is enabled.</summary>
    [JsonPropertyName("enableOnlineEvaluationOutputFile")]
    public bool? EnableOnlineEvaluationOutputFile { get; set; }
}

/// <summary>Redacted repository and GitHub host settings for a session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSettingsRepoSnapshot
{
    /// <summary>Checked-out repository branch.</summary>
    [JsonPropertyName("branch")]
    public string? Branch { get; set; }

    /// <summary>Checked-out commit SHA.</summary>
    [JsonPropertyName("commit")]
    public string? Commit { get; set; }

    /// <summary>GitHub server host name.</summary>
    [JsonPropertyName("host")]
    public string? Host { get; set; }

    /// <summary>Protocol used to access the GitHub host.</summary>
    [JsonPropertyName("hostProtocol")]
    public string? HostProtocol { get; set; }

    /// <summary>GitHub repository database ID.</summary>
    [JsonPropertyName("id")]
    public double? Id { get; set; }

    /// <summary>Repository name.</summary>
    [JsonPropertyName("name")]
    public string? Name { get; set; }

    /// <summary>GitHub repository owner database ID.</summary>
    [JsonPropertyName("ownerId")]
    public double? OwnerId { get; set; }

    /// <summary>Repository owner login.</summary>
    [JsonPropertyName("ownerName")]
    public string? OwnerName { get; set; }

    /// <summary>Number of commits in the pull request.</summary>
    [JsonPropertyName("prCommitCount")]
    public double? PrCommitCount { get; set; }

    /// <summary>Whether the repository is writable.</summary>
    [JsonPropertyName("readWrite")]
    public bool? ReadWrite { get; set; }

    /// <summary>GitHub secret-scanning service URL.</summary>
    [JsonPropertyName("secretScanningUrl")]
    public string? SecretScanningUrl { get; set; }

    /// <summary>GitHub server base URL.</summary>
    [JsonPropertyName("serverUrl")]
    public string? ServerUrl { get; set; }
}

/// <summary>Redacted validation and memory-tool settings for a session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionSettingsValidationSnapshot
{
    /// <summary>Whether advisory validation is enabled.</summary>
    [JsonPropertyName("advisoryEnabled")]
    public bool? AdvisoryEnabled { get; set; }

    /// <summary>Whether CodeQL validation is enabled.</summary>
    [JsonPropertyName("codeqlEnabled")]
    public bool? CodeqlEnabled { get; set; }

    /// <summary>Whether code-review validation is enabled.</summary>
    [JsonPropertyName("codeReviewEnabled")]
    public bool? CodeReviewEnabled { get; set; }

    /// <summary>Model used for code-review validation.</summary>
    [JsonPropertyName("codeReviewModel")]
    public string? CodeReviewModel { get; set; }

    /// <summary>Dependabot validation timeout budget in seconds.</summary>
    [JsonPropertyName("dependabotTimeout")]
    public double? DependabotTimeout { get; set; }

    /// <summary>Whether the memory-store tool is enabled.</summary>
    [JsonPropertyName("memoryStoreEnabled")]
    public bool? MemoryStoreEnabled { get; set; }

    /// <summary>Whether the memory-vote tool is enabled.</summary>
    [JsonPropertyName("memoryVoteEnabled")]
    public bool? MemoryVoteEnabled { get; set; }

    /// <summary>Whether secret-scanning validation is enabled.</summary>
    [JsonPropertyName("secretScanningEnabled")]
    public bool? SecretScanningEnabled { get; set; }

    /// <summary>General validation timeout budget in seconds.</summary>
    [JsonPropertyName("timeout")]
    public double? Timeout { get; set; }
}

/// <summary>Redacted, serializable view of session runtime settings for SDK boundary consumers. Secrets and raw feature flags are intentionally excluded.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSettingsSnapshot
{
    /// <summary>Name of the SDK client that created the session.</summary>
    [JsonPropertyName("clientName")]
    public string? ClientName { get; set; }

    /// <summary>Redacted job settings.</summary>
    [JsonPropertyName("job")]
    public SessionSettingsJobSnapshot Job { get => field ??= new(); set; }

    /// <summary>Redacted model routing settings.</summary>
    [JsonPropertyName("model")]
    public SessionSettingsModelSnapshot Model { get => field ??= new(); set; }

    /// <summary>Online-evaluation settings safe for SDK consumers.</summary>
    [JsonPropertyName("onlineEvaluation")]
    public SessionSettingsOnlineEvaluationSnapshot OnlineEvaluation { get => field ??= new(); set; }

    /// <summary>Redacted repository and host settings.</summary>
    [JsonPropertyName("repo")]
    public SessionSettingsRepoSnapshot Repo { get => field ??= new(); set; }

    /// <summary>Session start time as Unix epoch milliseconds.</summary>
    [JsonPropertyName("startTimeMs")]
    public double? StartTimeMs { get; set; }

    /// <summary>Session timeout in milliseconds.</summary>
    [JsonPropertyName("timeoutMs")]
    public double? TimeoutMs { get; set; }

    /// <summary>Redacted validation and memory-tool settings.</summary>
    [JsonPropertyName("validation")]
    public SessionSettingsValidationSnapshot Validation { get => field ??= new(); set; }

    /// <summary>Agent runtime version selector copied from the session settings, such as `latest` or a runtime release identifier.</summary>
    [JsonPropertyName("version")]
    public string? Version { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSettingsSnapshotRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of evaluating a Rust-owned settings predicate.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSettingsEvaluatePredicateResult
{
    /// <summary>Whether the named settings predicate evaluated to enabled.</summary>
    [JsonPropertyName("enabled")]
    public bool Enabled { get; set; }
}

/// <summary>Named Rust-owned settings predicate to evaluate for this session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionSettingsEvaluatePredicateRequest
{
    /// <summary>Predicate name. The runtime owns the raw feature-flag names and composition logic.</summary>
    [JsonPropertyName("name")]
    public SessionSettingsPredicateName Name { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Tool name for tool-scoped predicates such as trivial-change handling.</summary>
    [JsonPropertyName("toolName")]
    public string? ToolName { get; set; }
}

/// <summary>Content-exclusion decision for one requested path.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ContentExclusionPathCheck
{
    /// <summary>Whether the session's complete content-exclusion policy excludes the path.</summary>
    [JsonPropertyName("excluded")]
    public bool Excluded { get; set; }

    /// <summary>The path supplied by the caller.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;
}

/// <summary>Batch content-exclusion result. Callers must fail closed when policy evaluation is unavailable.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ContentExclusionCheckPathsResult
{
    /// <summary>Whether the session's policy service was available for the complete batch. When false, checks is empty and callers must treat every requested path as excluded.</summary>
    [JsonPropertyName("available")]
    public bool Available { get; set; }

    /// <summary>Per-path decisions in request order. Empty when available is false.</summary>
    [JsonPropertyName("checks")]
    public IList<ContentExclusionPathCheck> Checks { get => field ??= []; set; }
}

/// <summary>Local file system absolute paths within the session working directory to check against its content-exclusion policy.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ContentExclusionCheckPathsRequest
{
    /// <summary>Local file system absolute paths within the session working directory to check. Results are returned in the same order, including duplicates.</summary>
    [JsonPropertyName("paths")]
    public IList<string> Paths { get => field ??= []; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifier of the spawned process, used to correlate streamed output and exit notifications.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ShellExecResult
{
    /// <summary>Unique identifier for tracking streamed output.</summary>
    [JsonPropertyName("processId")]
    public string ProcessId { get; set; } = string.Empty;
}

/// <summary>Shell command to run, with optional working directory and timeout in milliseconds.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ShellExecRequest
{
    /// <summary>Shell command to execute.</summary>
    [JsonPropertyName("command")]
    public string Command { get; set; } = string.Empty;

    /// <summary>Working directory (defaults to session working directory).</summary>
    [JsonPropertyName("cwd")]
    public string? Cwd { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Timeout in milliseconds (default: 30000).</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("timeout")]
    public TimeSpan? Timeout { get; set; }
}

/// <summary>Indicates whether the signal was delivered; false if the process was unknown or already exited.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ShellKillResult
{
    /// <summary>Whether the signal was sent successfully.</summary>
    [JsonPropertyName("killed")]
    public bool Killed { get; set; }
}

/// <summary>Identifier of a process previously returned by "shell.exec" and the signal to send.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ShellKillRequest
{
    /// <summary>Process identifier returned by shell.exec.</summary>
    [JsonPropertyName("processId")]
    public string ProcessId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Signal to send (default: SIGTERM).</summary>
    [JsonPropertyName("signal")]
    public ShellKillSignal? Signal { get; set; }
}

/// <summary>Result of a user-requested shell command.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UserRequestedShellCommandResult
{
    /// <summary>Error output when the execution failed.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Process exit code, when available.</summary>
    [JsonPropertyName("exitCode")]
    public long? ExitCode { get; set; }

    /// <summary>Captured command output.</summary>
    [JsonPropertyName("output")]
    public string Output { get; set; } = string.Empty;

    /// <summary>Whether the command completed successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }

    /// <summary>Tool call id emitted for the shell execution.</summary>
    [JsonPropertyName("toolCallId")]
    public string ToolCallId { get; set; } = string.Empty;
}

/// <summary>User-requested shell command and cancellation handle.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ShellExecuteUserRequestedRequest
{
    /// <summary>Shell command to execute.</summary>
    [JsonPropertyName("command")]
    public string Command { get; set; } = string.Empty;

    /// <summary>Caller-provided cancellation handle for this execution.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Cancellation result for a user-requested shell command.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CancelUserRequestedShellCommandResult
{
    /// <summary>Whether an in-flight execution was found and signalled to cancel.</summary>
    [JsonPropertyName("cancelled")]
    public bool Cancelled { get; set; }
}

/// <summary>User-requested shell execution cancellation handle.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ShellCancelUserRequestedRequest
{
    /// <summary>Request ID previously passed to executeUserRequested.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Post-compaction context window usage breakdown.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryCompactContextWindow
{
    /// <summary>Token count from non-system messages (user, assistant, tool).</summary>
    [JsonPropertyName("conversationTokens")]
    public long? ConversationTokens { get; set; }

    /// <summary>Current total tokens in the context window (system + conversation + tool definitions).</summary>
    [JsonPropertyName("currentTokens")]
    public long CurrentTokens { get; set; }

    /// <summary>Current number of messages in the conversation.</summary>
    [JsonPropertyName("messagesLength")]
    public long MessagesLength { get; set; }

    /// <summary>Token count from system message(s).</summary>
    [JsonPropertyName("systemTokens")]
    public long? SystemTokens { get; set; }

    /// <summary>Maximum token count for the model's context window.</summary>
    [JsonPropertyName("tokenLimit")]
    public long TokenLimit { get; set; }

    /// <summary>Token count from tool definitions.</summary>
    [JsonPropertyName("toolDefinitionsTokens")]
    public long? ToolDefinitionsTokens { get; set; }
}

/// <summary>Compaction outcome with the number of tokens and messages removed, summary text, and the resulting context window breakdown.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryCompactResult
{
    /// <summary>Post-compaction context window usage breakdown.</summary>
    [JsonPropertyName("contextWindow")]
    public HistoryCompactContextWindow? ContextWindow { get; set; }

    /// <summary>Number of messages removed during compaction.</summary>
    [JsonPropertyName("messagesRemoved")]
    public long MessagesRemoved { get; set; }

    /// <summary>Whether compaction completed successfully.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }

    /// <summary>Summary text produced by compaction. Omitted when compaction did not produce a summary (e.g. failure path).</summary>
    [JsonPropertyName("summaryContent")]
    public string? SummaryContent { get; set; }

    /// <summary>Number of tokens freed by compaction.</summary>
    [JsonPropertyName("tokensRemoved")]
    public long TokensRemoved { get; set; }
}

/// <summary>RPC data type for SessionHistoryCompact operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionHistoryCompactRequest
{
    /// <summary>Optional user-provided instructions to focus the compaction summary.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(4000)]
    [JsonPropertyName("customInstructions")]
    public string? CustomInstructions { get; set; }

    /// <summary>Context window token limit this compaction is targeting, recorded as the `tokenLimit` on the persisted `session.compaction_start` / `session.compaction_complete` events. Set it when the compaction targets a window other than the compacting model's own, e.g. switching to a model with a smaller context window: the compaction still runs on the current model, so the limit that motivated it would otherwise be lost. When absent, the events record the compacting model's own resolved limit. Attribution metadata only - it does not change how much the compaction removes.</summary>
    [JsonPropertyName("tokenLimit")]
    public long? TokenLimit { get; set; }

    /// <summary>What initiated this compaction request, recorded as the `trigger` on the persisted `session.compaction_start` / `session.compaction_complete` events. When absent, the compaction is persisted without trigger attribution (initiator unknown).</summary>
    [JsonPropertyName("trigger")]
    public SessionHistoryCompactRequestTrigger? Trigger { get; set; }
}

/// <summary>RPC data type for SessionHistoryCompactRequestWithSession operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionHistoryCompactRequestWithSession
{
    /// <summary>Optional user-provided instructions to focus the compaction summary.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MaxLength(4000)]
    [JsonPropertyName("customInstructions")]
    public string? CustomInstructions { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Context window token limit this compaction is targeting, recorded as the `tokenLimit` on the persisted `session.compaction_start` / `session.compaction_complete` events. Set it when the compaction targets a window other than the compacting model's own, e.g. switching to a model with a smaller context window: the compaction still runs on the current model, so the limit that motivated it would otherwise be lost. When absent, the events record the compacting model's own resolved limit. Attribution metadata only - it does not change how much the compaction removes.</summary>
    [JsonPropertyName("tokenLimit")]
    public long? TokenLimit { get; set; }

    /// <summary>What initiated this compaction request, recorded as the `trigger` on the persisted `session.compaction_start` / `session.compaction_complete` events. When absent, the compaction is persisted without trigger attribution (initiator unknown).</summary>
    [JsonPropertyName("trigger")]
    public SessionHistoryCompactRequestTrigger? Trigger { get; set; }
}

/// <summary>Number of events that were removed by the truncation.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryTruncateResult
{
    /// <summary>Failure detail when checkpointCleanupFailed is true.</summary>
    [JsonPropertyName("checkpointCleanupError")]
    public string? CheckpointCleanupError { get; set; }

    /// <summary>True when conversation truncation succeeded but post-truncation workspace checkpoint cleanup failed. History is already truncated; callers may still prune snapshots but should report a checkpoint-cleanup rather than a truncation failure.</summary>
    [JsonPropertyName("checkpointCleanupFailed")]
    public bool? CheckpointCleanupFailed { get; set; }

    /// <summary>Number of events that were removed.</summary>
    [JsonPropertyName("eventsRemoved")]
    public long EventsRemoved { get; set; }
}

/// <summary>Identifier of the event to truncate to; this event and all later events are removed.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class HistoryTruncateRequest
{
    /// <summary>Event ID to truncate to. This event and all events after it are removed from the session.</summary>
    [JsonPropertyName("eventId")]
    public string EventId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A root user turn that the session can rewind to.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryRewindPoint
{
    /// <summary>Whether at least one file in this turn or a later turn can be restored.</summary>
    [JsonPropertyName("canRestoreFiles")]
    public bool CanRestoreFiles { get; set; }

    /// <summary>ID of the user.message event that begins the discarded suffix.</summary>
    [JsonPropertyName("eventId")]
    public string EventId { get; set; } = string.Empty;

    /// <summary>Number of unique files in this turn and all later turns that have captured changes.</summary>
    [JsonPropertyName("fileCount")]
    public long FileCount { get; set; }

    /// <summary>Whether this turn was an automatically injected autopilot continuation.</summary>
    [JsonPropertyName("isAutopilotContinuation")]
    public bool IsAutopilotContinuation { get; set; }

    /// <summary>Lines added by this turn's captured file changes.</summary>
    [JsonPropertyName("linesAdded")]
    public long LinesAdded { get; set; }

    /// <summary>Lines removed by this turn's captured file changes.</summary>
    [JsonPropertyName("linesRemoved")]
    public long LinesRemoved { get; set; }

    /// <summary>ISO timestamp of the user turn.</summary>
    [JsonPropertyName("timestamp")]
    public string Timestamp { get; set; } = string.Empty;

    /// <summary>Whether this turn itself captured any file changes.</summary>
    [JsonPropertyName("turnChangedFiles")]
    public bool TurnChangedFiles { get; set; }

    /// <summary>User-visible message text for the turn.</summary>
    [JsonPropertyName("userMessage")]
    public string UserMessage { get; set; } = string.Empty;
}

/// <summary>Rewind points and file-change-tracking availability for the session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryListRewindPointsResult
{
    /// <summary>Whether this session captured file changes from its first turn.</summary>
    [JsonPropertyName("fileChangeTrackingEnabled")]
    public bool FileChangeTrackingEnabled { get; set; }

    /// <summary>Root user turns in chronological order. Empty when `unavailableReason` is set.</summary>
    [JsonPropertyName("points")]
    public IList<HistoryRewindPoint> Points { get => field ??= []; set; }

    /// <summary>Why the listed points could not be produced, when applicable; the points list is empty whenever it is set. `unsupported-remote-session` is permanent for the session and comes with `fileChangeTrackingEnabled: false`. `session-busy` is transient and only ever reported by a session that *is* tracking (`fileChangeTrackingEnabled: true`), because the file-change captures cannot be read while work that may still mutate them is in flight; the same request succeeds once the session settles, so a client that wants points should retry rather than treat it as a failure. It is never `file-change-tracking-disabled`: an untracked local session still lists conversation-only points and reports that through `fileChangeTrackingEnabled: false`.</summary>
    [JsonPropertyName("unavailableReason")]
    public HistoryRewindUnavailableReason? UnavailableReason { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionHistoryListRewindPointsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A file that a conversation-and-files rewind would restore.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryRewindFilePreview
{
    /// <summary>Aggregate change made across the discarded turns.</summary>
    [JsonPropertyName("changeType")]
    public HistoryRewindChangeType ChangeType { get; set; }

    /// <summary>Lines added across the discarded turns.</summary>
    [JsonPropertyName("linesAdded")]
    public long LinesAdded { get; set; }

    /// <summary>Lines removed across the discarded turns.</summary>
    [JsonPropertyName("linesRemoved")]
    public long LinesRemoved { get; set; }

    /// <summary>Absolute path of the captured file.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;
}

/// <summary>Files and aggregate changes for a prospective rewind.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryPreviewRewindResult
{
    /// <summary>Whether file restore is available for this session. This is authoritative: switch on it and read `reason` only when it is false.</summary>
    [JsonPropertyName("available")]
    public bool Available { get; set; }

    /// <summary>Number of unique files in the preview.</summary>
    [JsonPropertyName("fileCount")]
    public long FileCount { get; set; }

    /// <summary>Files ordered by path.</summary>
    [JsonPropertyName("files")]
    public IList<HistoryRewindFilePreview> Files { get => field ??= []; set; }

    /// <summary>Why file restore is unavailable, when applicable. Populated only when `available` is false and never set when `available` is true.</summary>
    [JsonPropertyName("reason")]
    public HistoryRewindUnavailableReason? Reason { get; set; }
}

/// <summary>Event boundary to preview for conversation-and-files rewind.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class HistoryPreviewRewindRequest
{
    /// <summary>ID of the user.message event that begins the discarded suffix.</summary>
    [JsonPropertyName("eventId")]
    public string EventId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A captured file that rewind intentionally left unchanged.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistorySkippedFileRestore
{
    /// <summary>Absolute path of the skipped file.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Reason the file was not restored.</summary>
    [JsonPropertyName("reason")]
    public HistoryFileRestoreSkipReason Reason { get; set; }
}

/// <summary>Structured outcome of a rewind request.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryRewindResult
{
    /// <summary>Failure detail. Set only for the failure and partial-failure outcomes (`files-rolled-back`, `rollback-incomplete`, `truncation-failed`, `checkpoint-cleanup-failed`, `snapshot-prune-failed`); omitted for `success` and for the unavailable outcomes (`session-busy`, `file-change-tracking-disabled`, `unsupported-remote-session`).</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }

    /// <summary>Number of persisted events removed by conversation truncation. Present only when truncation succeeded (outcomes `success`, `checkpoint-cleanup-failed`, and `snapshot-prune-failed`); omitted for every unavailable outcome (`session-busy`, `file-change-tracking-disabled`, `unsupported-remote-session`) and for `truncation-failed`, `files-rolled-back`, and `rollback-incomplete`.</summary>
    [JsonPropertyName("eventsRemoved")]
    public long? EventsRemoved { get; set; }

    /// <summary>Overall rewind outcome. This discriminates the result: it governs which of the remaining fields are populated, so consumers must switch on it before reading `eventsRemoved`, `restoredFiles`, `skippedFiles`, or `error`. See each field for the outcomes that populate it.</summary>
    [JsonPropertyName("outcome")]
    public HistoryRewindOutcome Outcome { get; set; }

    /// <summary>Absolute paths restored to their captured preimages. Always empty for conversation-only rewinds and for the unavailable outcomes (`session-busy`, `file-change-tracking-disabled`, `unsupported-remote-session`); only conversation-and-files outcomes that reached the file-restore stage populate it.</summary>
    [JsonPropertyName("restoredFiles")]
    public IList<string> RestoredFiles { get => field ??= []; set; }

    /// <summary>Captured files intentionally left unchanged. Always empty for conversation-only rewinds and for the unavailable outcomes (`session-busy`, `file-change-tracking-disabled`, `unsupported-remote-session`); only conversation-and-files outcomes that reached the file-restore stage populate it.</summary>
    [JsonPropertyName("skippedFiles")]
    public IList<HistorySkippedFileRestore> SkippedFiles { get => field ??= []; set; }
}

/// <summary>Boundary and mode for rewinding session history.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class HistoryRewindRequest
{
    /// <summary>ID of the user.message event that begins the discarded suffix.</summary>
    [JsonPropertyName("eventId")]
    public string EventId { get; set; } = string.Empty;

    /// <summary>Whether to rewind only conversation history or also restore captured files.</summary>
    [JsonPropertyName("mode")]
    public HistoryRewindMode Mode { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether an in-progress background compaction was cancelled.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryCancelBackgroundCompactionResult
{
    /// <summary>Whether an in-progress background compaction was cancelled. False when no compaction was running, when the session is remote, or when the underlying processor was unavailable.</summary>
    [JsonPropertyName("cancelled")]
    public bool Cancelled { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionHistoryCancelBackgroundCompactionRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether an in-progress manual compaction was aborted.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryAbortManualCompactionResult
{
    /// <summary>Whether an in-progress manual compaction was aborted. False when no manual compaction was running, when its abort controller was already aborted, or when the session is remote.</summary>
    [JsonPropertyName("aborted")]
    public bool Aborted { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionHistoryAbortManualCompactionRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Markdown summary of the conversation context (empty when not available).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistorySummarizeForHandoffResult
{
    /// <summary>Markdown summary of the conversation context produced by an LLM. Empty string when there are no messages or when the session does not support local summarization.</summary>
    [JsonPropertyName("summary")]
    public string Summary { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionHistorySummarizeForHandoffRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>What a successful clear removed. A clear that could not be applied rejects instead of reporting a count.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryClearContextResult
{
    /// <summary>Number of non-system, non-developer messages that were removed from the conversation. Zero only when the window already held no conversation.</summary>
    [JsonPropertyName("messagesCleared")]
    public long MessagesCleared { get; set; }
}

/// <summary>Parameters for clearing the conversation and seeding the window that replaces it.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class HistoryClearContextRequest
{
    /// <summary>First user message of the fresh context window. Required: a cleared window holding only system and developer messages is not a conversation a model can answer, so every clear seeds the window it creates. Delivered by the enclosing turn driver once the agentic loop exits, which is why the call must be made from inside a tool handler.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>User-facing pending queue entry, with kind and display text for a queued message, slash command, or model change.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueuePendingItems
{
    /// <summary>Agent mode stored on this queued entry, as stamped when it was enqueued. Items without an explicit mode report interactive. This is not necessarily the mode that will constrain the turn: a plan or autopilot session applies its own write gate, continuation loop and permission posture to every drained item regardless of the mode stored here.</summary>
    [JsonPropertyName("agentMode")]
    public SendAgentMode AgentMode { get; set; }

    /// <summary>Human-readable text to display for this queue entry in the UI.</summary>
    [JsonPropertyName("displayText")]
    public string DisplayText { get; set; } = string.Empty;

    /// <summary>Stable opaque id for the canonical queued item. Batch rows share one id.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Whether this item is a queued user message or a queued slash command / model change.</summary>
    [JsonPropertyName("kind")]
    public QueuePendingItemsKind Kind { get; set; }

    /// <summary>Stable identity of the queued user message. Present for message rows and absent for slash commands and model changes.</summary>
    [JsonPropertyName("messageId")]
    public string? MessageId { get; set; }
}

/// <summary>Snapshot of the session's pending queued items and immediate-steering messages.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueuePendingItemsResult
{
    /// <summary>How many leading entries of `steeringMessages` have already been folded into the running turn (and so have an emitted `user.message`), as opposed to still waiting for one. Absent for hosts that do not distinguish the two.</summary>
    [JsonPropertyName("inFlightSteeringCount")]
    public long? InFlightSteeringCount { get; set; }

    /// <summary>Pending queued items in submission order. Includes user messages, queued slash commands, and queued model changes; omits internal system items.</summary>
    [JsonPropertyName("items")]
    public IList<QueuePendingItems> Items { get => field ??= []; set; }

    /// <summary>Display text for messages currently in the immediate steering queue (interjections sent during a running turn).</summary>
    [JsonPropertyName("steeringMessages")]
    public IList<string> SteeringMessages { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionQueuePendingItemsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Internal snapshot of native queue state for local session orchestration.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueSnapshotResult
{
    /// <summary>Insertion orders for queued items, aligned with `items`.</summary>
    [JsonPropertyName("itemOrders")]
    public IList<long>? ItemOrders { get; set; }

    /// <summary>User-facing pending items in FIFO order.</summary>
    [JsonPropertyName("items")]
    public IList<QueuePendingItems> Items { get => field ??= []; set; }

    /// <summary>Insertion orders for immediate steering messages, aligned with `steeringMessages`.</summary>
    [JsonPropertyName("steeringMessageOrders")]
    public IList<long>? SteeringMessageOrders { get; set; }

    /// <summary>Immediate steering messages waiting for an active turn.</summary>
    [JsonPropertyName("steeringMessages")]
    public IList<string> SteeringMessages { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionQueueSnapshotRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of moving a queued item.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueMoveItemResult
{
    /// <summary>True when the item changed position; false when it was already at the requested position.</summary>
    [JsonPropertyName("changed")]
    public bool Changed { get; set; }
}

/// <summary>Parameters for moving a queued item by stable id.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueMoveItemRequest
{
    /// <summary>Stable opaque queued-item id.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Zero-based target position in the public visible queue. Values outside the queue clamp to an end.</summary>
    [JsonPropertyName("toPosition")]
    public long ToPosition { get; set; }
}

/// <summary>Result of inserting a queued message.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueInsertAtResult
{
    /// <summary>Fresh stable opaque id assigned to the inserted item.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;
}

/// <summary>Serializable message fields accepted by queue.insertAt.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueInsertMessage
{
    /// <summary>Optional explicit agent mode. When omitted, the session's current mode is assigned.</summary>
    [JsonPropertyName("agentMode")]
    public SendAgentMode? AgentMode { get; set; }

    /// <summary>Optional attachments for the message.</summary>
    [JsonPropertyName("attachments")]
    public IList<Attachment>? Attachments { get; set; }

    /// <summary>Whether the message is billable.</summary>
    [JsonPropertyName("billable")]
    public bool? Billable { get; set; }

    /// <summary>Accepted for internal SendOptions compatibility but ignored; delivery is derived from current session activity.</summary>
    [JsonPropertyName("delivery")]
    public string? Delivery { get; set; }

    /// <summary>Optional user-facing display text.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Accepted for SendOptions compatibility but ignored; inserted items always use queued delivery semantics.</summary>
    [JsonPropertyName("mode")]
    public SendMode? Mode { get; set; }

    /// <summary>Accepted for SendOptions compatibility but ignored; the requested public position controls placement.</summary>
    [JsonPropertyName("prepend")]
    public bool? Prepend { get; set; }

    /// <summary>The user message text.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Per-turn request headers.</summary>
    [JsonPropertyName("requestHeaders")]
    public IDictionary<string, string>? RequestHeaders { get; set; }

    /// <summary>Required tool name for the turn, when any.</summary>
    [JsonPropertyName("requiredTool")]
    public string? RequiredTool { get; set; }

    /// <summary>Optional provenance source. `system` is rejected: it would hide the inserted row from `pendingItems` and make it unaddressable while still executing, so inserted items must stay visible.</summary>
    [JsonPropertyName("source")]
    public string? Source { get; set; }

    /// <summary>Accepted for SendOptions compatibility but ignored; insertion scheduling is controlled by the queue drain state.</summary>
    [JsonPropertyName("wait")]
    public bool? Wait { get; set; }
}

/// <summary>Parameters for inserting a queued message at a public visible position.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueInsertAtRequest
{
    /// <summary>Queued message contents and delivery metadata.</summary>
    [JsonPropertyName("message")]
    public QueueInsertMessage Message { get => field ??= new(); set; }

    /// <summary>Zero-based position in the public visible queue. Values outside the queue clamp to an end.</summary>
    [JsonPropertyName("position")]
    public long Position { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of removing a queued item.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueRemoveAtResult
{
    /// <summary>True when the addressed item was removed.</summary>
    [JsonPropertyName("removed")]
    public bool Removed { get; set; }
}

/// <summary>Parameters for removing a queued item by stable id.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueRemoveAtRequest
{
    /// <summary>Stable opaque ID of the queued item to remove.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of editing a queued message.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueUpdateTextResult
{
    /// <summary>True when the stored text changed.</summary>
    [JsonPropertyName("updated")]
    public bool Updated { get; set; }
}

/// <summary>Parameters for editing a single queued message.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueUpdateTextRequest
{
    /// <summary>Optional replacement prompt displayed to the user.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Stable opaque ID of the queued item to edit.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Replacement prompt sent to the model.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of duplicating a queued item.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueDuplicateAtResult
{
    /// <summary>Fresh stable opaque id assigned to the duplicate.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;
}

/// <summary>Parameters for duplicating a queued item.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueDuplicateAtRequest
{
    /// <summary>Stable opaque ID of the queued item to duplicate.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Parameters for acquiring or releasing the queued-lane drain pause. Acquisition is exclusive and non-idempotent: `paused: true` against an already-paused session fails with `queue_already_paused`. The pause is never released automatically — it is not tied to the caller's lifetime, so a client that exits without sending `paused: false` leaves the lane frozen. Release is unowned: `paused: false` clears the pause for any caller, including one that never acquired it.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueSetDrainPausedRequest
{
    /// <summary>Whether queued-lane draining should be paused.</summary>
    [JsonPropertyName("paused")]
    public bool Paused { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of trying to steer a queued message into a live turn.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueSendNowResult
{
    /// <summary>True when the item was accepted into the steering lane; false when no main turn was live.</summary>
    [JsonPropertyName("steered")]
    public bool Steered { get; set; }
}

/// <summary>Parameters for steering a queued message into a live turn.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueSendNowRequest
{
    /// <summary>Stable opaque ID of the queued item to steer into the live turn.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Whether the native queue has pending work.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueHasPendingResult
{
    /// <summary>True when queued or immediate native work is pending.</summary>
    [JsonPropertyName("hasPending")]
    public bool HasPending { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionQueueHasPendingRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Whether a deferred-idle drain should run.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueBeginDeferredIdleDrainResult
{
    /// <summary>True when the host should run finishDeferredIdleDrain asynchronously.</summary>
    [JsonPropertyName("shouldDrain")]
    public bool ShouldDrain { get; set; }
}

/// <summary>Inputs for starting a deferred-idle drain.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueBeginDeferredIdleDrainRequest
{
    /// <summary>Whether the host still has active background work.</summary>
    [JsonPropertyName("activeBackgroundWork")]
    public bool ActiveBackgroundWork { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Action selected by the native deferred-idle drain.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueFinishDeferredIdleDrainResult
{
    /// <summary>Whether the deferred idle was caused by an aborted foreground turn.</summary>
    [JsonPropertyName("aborted")]
    public bool Aborted { get; set; }

    /// <summary>One of none, processQueue, or emitSessionIdle.</summary>
    [JsonPropertyName("action")]
    public string Action { get; set; } = string.Empty;
}

/// <summary>Inputs for completing a deferred-idle drain.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueFinishDeferredIdleDrainRequest
{
    /// <summary>Whether the host still has active background work.</summary>
    [JsonPropertyName("activeBackgroundWork")]
    public bool ActiveBackgroundWork { get; set; }

    /// <summary>Whether native queued work remains.</summary>
    [JsonPropertyName("hasPending")]
    public bool HasPending { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Inputs for marking session.idle deferred in native state.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueDeferSessionIdleRequest
{
    /// <summary>Whether the deferred idle was caused by an aborted foreground turn.</summary>
    [JsonPropertyName("aborted")]
    public bool Aborted { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether a user-facing pending item was removed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueRemoveMostRecentResult
{
    /// <summary>True if a user-facing pending item was removed (LIFO across both queues); false when no removable items remained.</summary>
    [JsonPropertyName("removed")]
    public bool Removed { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionQueueRemoveMostRecentRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionQueueClearRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Internal filter for consuming queued system notifications.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueConsumeSystemNotificationsRequest
{
    /// <summary>Opaque runtime-owned filter object.</summary>
    [JsonPropertyName("filter")]
    public JsonElement Filter { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of enqueueing the resume-pending wake item.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class QueueEnqueueResumePendingResult
{
    /// <summary>True when a wake item was newly queued.</summary>
    [JsonPropertyName("queued")]
    public bool Queued { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionQueueEnqueueResumePendingRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionQueueProcessRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Cursor, batch size, and optional long-poll/filter parameters for reading session events.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class EventLogReadRequest
{
    /// <summary>Optional non-empty list of subagent identifiers. When provided, only events owned by one of these agents are returned; ownership recognizes the event envelope's agentId plus legacy data.agentId and data.parentToolCallId markers. This filter takes precedence over agentScope.</summary>
    [JsonPropertyName("agentIds")]
    public IList<string>? AgentIds { get; set; }

    /// <summary>Agent-scope filter: 'primary' returns only main-agent events plus events whose type starts with 'subagent.' (matching the typed-subscription default behavior); 'all' returns events from all agents (matching wildcard-subscription behavior). Default is 'all' to preserve wildcard semantics for catch-up callers.</summary>
    [JsonPropertyName("agentScope")]
    public EventsAgentScope? AgentScope { get; set; }

    /// <summary>Opaque cursor returned by a previous read. Omit on the first call to start from the beginning of the session's persisted history.</summary>
    [JsonPropertyName("cursor")]
    public string? Cursor { get; set; }

    /// <summary>Direction to page through the session's persisted event history. 'forward' (default) pages from the cursor toward newer events (or from the start of history when no cursor is given). 'backward' enables tail-first reads: with no cursor it returns the NEWEST `max` events, and the returned cursor pages toward OLDER events on subsequent backward reads. Events within a returned batch are always in chronological (oldest-to-newest) order, even for a backward read. Backward reads cover PERSISTED history only; ephemeral events are never returned by a backward read. `direction` selects the INITIAL read only: the returned cursor is self-describing, so a continuation read pages in the cursor's own direction regardless of the `direction` passed alongside it — a forward cursor always pages forward and a backward cursor always pages backward. Pass the direction that matches the cursor to avoid confusion.</summary>
    [JsonPropertyName("direction")]
    public EventsReadDirection? Direction { get; set; }

    /// <summary>When false, skip ephemeral events entirely and return only durable (persisted) events. History-backfill callers that discard ephemerals anyway should set this so the read is bounded by the durable log length instead of racing the ephemeral ring on a busy session. Defaults to true (ephemerals are interleaved with durable events in creation order). Ignored by backward reads, which always cover persisted history only.</summary>
    [JsonPropertyName("includeEphemeral")]
    public bool? IncludeEphemeral { get; set; }

    /// <summary>Maximum number of events to return in this batch (1–1000, default 200).</summary>
    [JsonPropertyName("max")]
    public long? Max { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Either '*' to receive all event types, or a non-empty list of event types to receive.</summary>
    [JsonPropertyName("types")]
    public JsonElement? Types { get; set; }

    /// <summary>Milliseconds to wait for new events when the cursor is at the tail of history. 0 (default) returns immediately even if no events are available. Capped at 30000ms. Ephemeral events that arrive during the wait are delivered in this batch but are NOT replayable on a subsequent read (use a non-zero waitMs in your next call to capture future ephemerals as they happen). This applies to forward reads only: a backward read always returns immediately and ignores `waitMs`, because backward paging covers persisted history only while new events append at the tail (the opposite end from a backward page), so no blocking or ephemeral delivery can occur.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("waitMs")]
    public TimeSpan? Wait { get; set; }
}

/// <summary>Snapshot of the current tail cursor without returning any events. Use this when a consumer wants to subscribe to live events going forward without first paginating through the entire persisted history (which would happen if `read` were called without a cursor on a long-lived session).</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class EventLogTailResult
{
    /// <summary>Opaque cursor pointing at the current tail of the session's persisted-events history. Pass back to `read` to receive only events that arrive AFTER this snapshot. When the session has no events, this returns the same sentinel as an unset cursor (i.e. equivalent to omitting the cursor on a first read).</summary>
    [JsonPropertyName("cursor")]
    public string Cursor { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionEventLogTailRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Opaque handle representing an event-type interest registration.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RegisterEventInterestResult
{
    /// <summary>Opaque handle for this registration. Pass to releaseInterest to release. Each call to registerInterest produces a fresh handle, even when the same eventType is registered multiple times.</summary>
    [JsonPropertyName("handle")]
    public string Handle { get; set; } = string.Empty;
}

/// <summary>Event type to register consumer interest for, used by runtime gating logic.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class RegisterEventInterestParams
{
    /// <summary>The event type the consumer wants the runtime to treat as 'observed' for behavior-switching gating. Some runtime code paths inspect whether any consumer is interested in a specific event type and choose a different implementation accordingly (e.g. `mcp.oauth_required`: when interest is registered the runtime delegates interactive OAuth token acquisition to the consumer via `mcp.oauth_required` events; when no interest is registered the runtime still attempts non-interactive reconnect from cached or refreshable tokens, and only marks the server `needs-auth` if usable credentials are unavailable — it does not open a browser or start interactive OAuth without a consumer). SDK clients that long-poll events do NOT automatically appear as listeners to these gating checks — they must explicitly call `registerInterest` for each event type they want the runtime to count as having a consumer. Multiple registrations for the same event type from the same or different consumers are tracked independently and must each be released. See: `mcp.oauth_required`, `sampling.requested`, `auto_mode_switch.requested`, `session_limits_exhausted.requested`, `user_input.requested`, `elicitation.requested`, `command.queued`, `exit_plan_mode.requested`.</summary>
    [JsonPropertyName("eventType")]
    public string EventType { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the operation succeeded.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class EventLogReleaseInterestResult
{
    /// <summary>Whether the operation succeeded.</summary>
    [JsonPropertyName("success")]
    public bool Success { get; set; }
}

/// <summary>Opaque handle previously returned by `registerInterest` to release.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ReleaseEventInterestParams
{
    /// <summary>Handle returned by a previous `registerInterest` call. Idempotent: releasing an unknown or already-released handle is a no-op (returns success). When the last outstanding handle for an event type is released, the runtime reverts to its 'no consumer' code path for that event type.</summary>
    [JsonPropertyName("handle")]
    public string Handle { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Request count and cost metrics for this model.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageMetricsModelMetricRequests
{
    /// <summary>User-initiated premium request cost (with multiplier applied).</summary>
    [JsonPropertyName("cost")]
    public double Cost { get; set; }

    /// <summary>Number of API requests made with this model.</summary>
    [JsonPropertyName("count")]
    public long Count { get; set; }
}

/// <summary>Per-model token-detail entry containing the accumulated token count for one token type.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageMetricsModelMetricTokenDetail
{
    /// <summary>Accumulated token count for this token type.</summary>
    [JsonPropertyName("tokenCount")]
    public long TokenCount { get; set; }
}

/// <summary>Token usage metrics for this model.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageMetricsModelMetricUsage
{
    /// <summary>Total tokens read from prompt cache.</summary>
    [JsonPropertyName("cacheReadTokens")]
    public long CacheReadTokens { get; set; }

    /// <summary>Total tokens written to prompt cache.</summary>
    [JsonPropertyName("cacheWriteTokens")]
    public long CacheWriteTokens { get; set; }

    /// <summary>Total input tokens consumed.</summary>
    [JsonPropertyName("inputTokens")]
    public long InputTokens { get; set; }

    /// <summary>Total output tokens produced.</summary>
    [JsonPropertyName("outputTokens")]
    public long OutputTokens { get; set; }

    /// <summary>Total output tokens used for reasoning.</summary>
    [JsonPropertyName("reasoningTokens")]
    public long? ReasoningTokens { get; set; }
}

/// <summary>Per-model usage metrics, including request counts/costs, token usage, nano-AI units, and per-token-type details.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageMetricsModelMetric
{
    /// <summary>Latest known prompt-cache expiration for this model. A timestamp in the past indicates that the observed cache has expired.</summary>
    [JsonPropertyName("cacheExpiresAt")]
    public DateTimeOffset? CacheExpiresAt { get; set; }

    /// <summary>Request count and cost metrics for this model.</summary>
    [JsonPropertyName("requests")]
    public UsageMetricsModelMetricRequests Requests { get => field ??= new(); set; }

    /// <summary>Token count details per type.</summary>
    [JsonPropertyName("tokenDetails")]
    public IDictionary<string, UsageMetricsModelMetricTokenDetail>? TokenDetails { get; set; }

    /// <summary>Accumulated nano-AI units cost for this model.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public double? TotalNanoAiu { get; set; }

    /// <summary>Token usage metrics for this model.</summary>
    [JsonPropertyName("usage")]
    public UsageMetricsModelMetricUsage Usage { get => field ??= new(); set; }
}

/// <summary>Usage attributed to one agent instance, including its identity, API duration, AI units, and per-model breakdown.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageMetricsAgentMetric
{
    /// <summary>Human-readable label for this subagent invocation, copied from the originating `subagent.started` event. For task-tool subagents this is the invocation's task description rather than the agent's configured display name, so group by `agentName` for stable per-agent labels.</summary>
    [JsonPropertyName("agentDisplayName")]
    public string? AgentDisplayName { get; set; }

    /// <summary>Configured agent name, when this is a subagent.</summary>
    [JsonPropertyName("agentName")]
    public string? AgentName { get; set; }

    /// <summary>Per-model usage for this agent, keyed by model identifier.</summary>
    [JsonPropertyName("modelMetrics")]
    public IDictionary<string, UsageMetricsModelMetric> ModelMetrics { get => field ??= new Dictionary<string, UsageMetricsModelMetric>(); set; }

    /// <summary>Time spent in model API calls by this agent, in milliseconds.</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("totalApiDurationMs")]
    public TimeSpan TotalApiDuration { get; set; }

    /// <summary>Accumulated nano-AI units cost for this agent.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public double TotalNanoAiu { get; set; }
}

/// <summary>Aggregated code change metrics.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageMetricsCodeChanges
{
    /// <summary>Distinct file paths modified during the session.</summary>
    [JsonPropertyName("filesModified")]
    public IList<string> FilesModified { get => field ??= []; set; }

    /// <summary>Number of distinct files modified.</summary>
    [JsonPropertyName("filesModifiedCount")]
    public long FilesModifiedCount { get; set; }

    /// <summary>Total lines of code added.</summary>
    [JsonPropertyName("linesAdded")]
    public long LinesAdded { get; set; }

    /// <summary>Total lines of code removed.</summary>
    [JsonPropertyName("linesRemoved")]
    public long LinesRemoved { get; set; }
}

/// <summary>Session-wide token-detail entry containing the accumulated token count for one token type.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageMetricsTokenDetail
{
    /// <summary>Accumulated token count for this token type.</summary>
    [JsonPropertyName("tokenCount")]
    public long TokenCount { get; set; }
}

/// <summary>Accumulated session usage metrics, including premium request cost, token counts, model breakdown, and code-change totals.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageGetMetricsResult
{
    /// <summary>Per-agent usage metrics, keyed by agent instance identifier. The main conversation uses the stable key `main`.</summary>
    [JsonPropertyName("agentMetrics")]
    public IDictionary<string, UsageMetricsAgentMetric>? AgentMetrics { get; set; }

    /// <summary>Aggregated code change metrics.</summary>
    [JsonPropertyName("codeChanges")]
    public UsageMetricsCodeChanges CodeChanges { get => field ??= new(); set; }

    /// <summary>Currently active model identifier.</summary>
    [JsonPropertyName("currentModel")]
    public string? CurrentModel { get; set; }

    /// <summary>Input tokens from the most recent main-agent API call.</summary>
    [JsonPropertyName("lastCallInputTokens")]
    public long LastCallInputTokens { get; set; }

    /// <summary>Output tokens from the most recent main-agent API call.</summary>
    [JsonPropertyName("lastCallOutputTokens")]
    public long LastCallOutputTokens { get; set; }

    /// <summary>Per-model token and request metrics, keyed by model identifier.</summary>
    [JsonPropertyName("modelMetrics")]
    public IDictionary<string, UsageMetricsModelMetric> ModelMetrics { get => field ??= new Dictionary<string, UsageMetricsModelMetric>(); set; }

    /// <summary>ISO 8601 timestamp when the session started.</summary>
    [JsonPropertyName("sessionStartTime")]
    public DateTimeOffset SessionStartTime { get; set; }

    /// <summary>Session-wide per-token-type accumulated token counts.</summary>
    [JsonPropertyName("tokenDetails")]
    public IDictionary<string, UsageMetricsTokenDetail>? TokenDetails { get; set; }

    /// <summary>Total time spent in model API calls (milliseconds).</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("totalApiDurationMs")]
    public TimeSpan TotalApiDuration { get; set; }

    /// <summary>Session-wide accumulated nano-AI units cost.</summary>
    [JsonPropertyName("totalNanoAiu")]
    public double? TotalNanoAiu { get; set; }

    /// <summary>Total user-initiated premium request cost across all models (may be fractional due to multipliers).</summary>
    [JsonPropertyName("totalPremiumRequestCost")]
    public double TotalPremiumRequestCost { get; set; }

    /// <summary>Raw count of user-initiated API requests.</summary>
    [JsonPropertyName("totalUserRequests")]
    public long TotalUserRequests { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionUsageGetMetricsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Prediction result. Available results include prediction details; unavailable results include an explicit reason.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(SessionLimitPredictionResultAvailable), "available")]
[JsonDerivedType(typeof(SessionLimitPredictionResultUnavailable), "unavailable")]
public partial class SessionLimitPredictionResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>Baseline data provenance for a prediction.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionLimitPredictionBaselineData
{
    /// <summary>End of the baseline data slice.</summary>
    [JsonPropertyName("windowEnd")]
    public string WindowEnd { get; set; } = string.Empty;

    /// <summary>Start of the baseline data slice.</summary>
    [JsonPropertyName("windowStart")]
    public string WindowStart { get; set; } = string.Empty;
}

/// <summary>Semantic usage tier and its AI-credit cap.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionLimitPredictionTierOption
{
    /// <summary>AI-credit cap for this tier.</summary>
    [JsonPropertyName("cap")]
    public double Cap { get; set; }

    /// <summary>Semantic usage tier.</summary>
    [JsonPropertyName("tier")]
    public SessionLimitPredictionTier Tier { get; set; }
}

/// <summary>Explainable AI-credit session-limit prediction.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionLimitPredictionDetails
{
    /// <summary>Baseline data provenance.</summary>
    [JsonPropertyName("baselineData")]
    public SessionLimitPredictionBaselineData BaselineData { get => field ??= new(); set; }

    /// <summary>Client population used for the prediction.</summary>
    [JsonPropertyName("clientType")]
    public SessionLimitPredictionClientType ClientType { get; set; }

    /// <summary>Resolved model family when known.</summary>
    [JsonPropertyName("family")]
    public string? Family { get; set; }

    /// <summary>Model identifier used for lookup.</summary>
    [JsonPropertyName("modelId")]
    public string ModelId { get; set; } = string.Empty;

    /// <summary>Recommended maximum AI credits for this session.</summary>
    [JsonPropertyName("recommendedCap")]
    public double RecommendedCap { get; set; }

    /// <summary>Tier chosen as the recommended cap.</summary>
    [JsonPropertyName("recommendedTier")]
    public SessionLimitPredictionTier RecommendedTier { get; set; }

    /// <summary>Baseline fallback level used to create the prediction.</summary>
    [JsonPropertyName("source")]
    public SessionLimitPredictionSource Source { get; set; }

    /// <summary>Key matched at the source level, such as a model id, family id, or `global`.</summary>
    [JsonPropertyName("sourceKey")]
    public string SourceKey { get; set; } = string.Empty;

    /// <summary>Ordered usage tiers and their AI-credit caps.</summary>
    [JsonPropertyName("tiers")]
    public IList<SessionLimitPredictionTierOption> Tiers { get => field ??= []; set; }
}

/// <summary>The <c>available</c> variant of <see cref="SessionLimitPredictionResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SessionLimitPredictionResultAvailable : SessionLimitPredictionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "available";

    /// <summary>Predicted session limit details.</summary>
    [JsonPropertyName("prediction")]
    public required SessionLimitPredictionDetails Prediction { get; set; }
}

/// <summary>The <c>unavailable</c> variant of <see cref="SessionLimitPredictionResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class SessionLimitPredictionResultUnavailable : SessionLimitPredictionResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "unavailable";

    /// <summary>Reason no prediction is available.</summary>
    [JsonPropertyName("reason")]
    public required SessionLimitPredictionUnavailableReason Reason { get; set; }
}

/// <summary>RPC data type for SessionLimitPredictionPredict operations.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionLimitPredictionPredictRequest
{
    /// <summary>Client type to size for. Defaults to `cli-interactive`.</summary>
    [JsonPropertyName("clientType")]
    public SessionLimitPredictionClientType? ClientType { get; set; }

    /// <summary>Optional model identifier override. If omitted, the session's current model is used.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }
}

/// <summary>RPC data type for SessionLimitPredictionPredictRequestWithSession operations.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionLimitPredictionPredictRequestWithSession
{
    /// <summary>Client type to size for. Defaults to `cli-interactive`.</summary>
    [JsonPropertyName("clientType")]
    public SessionLimitPredictionClientType? ClientType { get; set; }

    /// <summary>Optional model identifier override. If omitted, the session's current model is used.</summary>
    [JsonPropertyName("modelId")]
    public string? ModelId { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>GitHub URL for the session and a flag indicating whether remote steering is enabled.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteEnableResult
{
    /// <summary>Whether remote steering is enabled.</summary>
    [JsonPropertyName("remoteSteerable")]
    public bool RemoteSteerable { get; set; }

    /// <summary>GitHub frontend URL for this session.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Optional remote session mode ("off", "export", or "on"); defaults to enabling both export and remote steering.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class RemoteEnableRequest
{
    /// <summary>Per-session remote mode. "off" disables remote, "export" exports session events to GitHub without enabling remote steering, "on" enables both export and remote steering.</summary>
    [JsonPropertyName("mode")]
    public RemoteSessionMode? Mode { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionRemoteDisableRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Persist a steerability change as a `session.remote_steerable_changed` event. Used by the host (CLI / SDK consumer) when it has just finished enabling or disabling steering on a remote exporter that the runtime does not directly own.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteNotifySteerableChangedResult
{
}

/// <summary>New remote-steerability state to persist as a `session.remote_steerable_changed` event.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class RemoteNotifySteerableChangedRequest
{
    /// <summary>Whether the session now supports remote steering via GitHub. The runtime persists this as a `session.remote_steerable_changed` event so resume/replay sees the up-to-date capability.</summary>
    [JsonPropertyName("remoteSteerable")]
    public bool RemoteSteerable { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Current sharing status and shareable GitHub URL for a session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class VisibilityGetResult
{
    /// <summary>Shareable GitHub URL for the session. Present when the session is synced and the URL can be resolved.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("shareUrl")]
    public string? ShareUrl { get; set; }

    /// <summary>Current sharing status. Absent when the session is not synced or the status could not be retrieved (e.g. the user is not authenticated).</summary>
    [JsonPropertyName("status")]
    public SessionVisibilityStatus? Status { get; set; }

    /// <summary>Whether the session has been synced to Mission Control (i.e. has a GitHub task). When false, the session cannot be shared and `status`/`shareUrl` are absent.</summary>
    [JsonPropertyName("synced")]
    public bool Synced { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionVisibilityGetRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Effective sharing status and shareable GitHub URL after updating session visibility.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class VisibilitySetResult
{
    /// <summary>Shareable GitHub URL for the session. Present when the session is synced and the URL can be resolved.</summary>
    [Url]
    [StringSyntax(StringSyntaxAttribute.Uri)]
    [JsonPropertyName("shareUrl")]
    public string? ShareUrl { get; set; }

    /// <summary>Effective sharing status after the update. May differ from the requested status for task types that are already visible to repository readers by default. Absent when the update could not be applied (e.g. the session is not synced or the user is not authenticated).</summary>
    [JsonPropertyName("status")]
    public SessionVisibilityStatus? Status { get; set; }

    /// <summary>Whether the session has been synced to Mission Control (i.e. has a GitHub task). When false, the visibility change could not be applied and `status`/`shareUrl` are absent.</summary>
    [JsonPropertyName("synced")]
    public bool Synced { get; set; }
}

/// <summary>Desired sharing status for the session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class VisibilitySetRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Sharing status to apply. "repo" makes the session visible to repository readers; "unshared" restricts it to the creator and collaborators.</summary>
    [JsonPropertyName("status")]
    public SessionVisibilityStatus Status { get; set; }
}

/// <summary>Scheduled prompt entry with ID, timing (`intervalMs`, `cron`, or `at`), prompt text, recurrence, and next run time.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ScheduleEntry
{
    /// <summary>Absolute fire time (epoch milliseconds) for a one-shot calendar schedule.</summary>
    [JsonPropertyName("at")]
    public long? At { get; set; }

    /// <summary>5-field cron expression for a recurring calendar schedule, evaluated in `tz`.</summary>
    [JsonPropertyName("cron")]
    public string? Cron { get; set; }

    /// <summary>Display-only label for the prompt as shown in the UI (e.g. `/skill-name` for a skill-invocation schedule). The actual enqueued prompt is `prompt`.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Sequential id assigned by the runtime within the session. Stable across resumes (rebuilt from the event log).</summary>
    [JsonPropertyName("id")]
    public long Id { get; set; }

    /// <summary>Interval between scheduled ticks, in milliseconds (relative-interval schedules).</summary>
    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]
    [JsonPropertyName("intervalMs")]
    public TimeSpan? Interval { get; set; }

    /// <summary>ISO 8601 timestamp when the next tick is scheduled to fire.</summary>
    [JsonPropertyName("nextRunAt")]
    public DateTimeOffset NextRunAt { get; set; }

    /// <summary>Prompt text that gets enqueued on every tick.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Whether the schedule re-arms after each tick (`/every`) or fires once (`/after`).</summary>
    [JsonPropertyName("recurring")]
    public bool Recurring { get; set; }

    /// <summary>True for a self-paced (`dynamic`) schedule: no fixed cadence; the model arms each next run via the `manage_schedule` `wakeup` action. `nextRunAt` is model-controlled.</summary>
    [JsonPropertyName("selfPaced")]
    public bool? SelfPaced { get; set; }

    /// <summary>IANA timezone the `cron` expression is evaluated in.</summary>
    [JsonPropertyName("tz")]
    public string? Tz { get; set; }
}

/// <summary>Snapshot of the currently active recurring prompts for this session.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ScheduleList
{
    /// <summary>Active scheduled prompts, ordered by id.</summary>
    [JsonPropertyName("entries")]
    public IList<ScheduleEntry> Entries { get => field ??= []; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionScheduleListRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionScheduleHydrateRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Whether the session currently has an active self-paced schedule.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleHasSelfPacedResult
{
    /// <summary>True when at least one active schedule is self-paced.</summary>
    [JsonPropertyName("hasSelfPaced")]
    public bool HasSelfPaced { get; set; }
}

/// <summary>Identifies the target session.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class SessionScheduleHasSelfPacedRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result of registering or re-arming a scheduled prompt.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleAddResult
{
    /// <summary>The registered or updated schedule entry.</summary>
    [JsonPropertyName("entry")]
    public ScheduleEntry? Entry { get; set; }

    /// <summary>User-facing validation error, when registration failed.</summary>
    [JsonPropertyName("error")]
    public string? Error { get; set; }
}

/// <summary>Register a relative-interval scheduled prompt.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleAddRequest
{
    /// <summary>Optional display-only prompt label.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Human-readable interval such as `30s`, `5m`, or `2h`.</summary>
    [JsonPropertyName("interval")]
    public string Interval { get; set; } = string.Empty;

    /// <summary>Prompt text to enqueue when the schedule fires.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Whether the schedule should re-arm after each tick. Defaults to true.</summary>
    [JsonPropertyName("recurring")]
    public bool? Recurring { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Register a cron scheduled prompt.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleAddCronRequest
{
    /// <summary>5-field cron expression.</summary>
    [JsonPropertyName("cron")]
    public string Cron { get; set; } = string.Empty;

    /// <summary>Optional display-only prompt label.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Prompt text to enqueue when the schedule fires.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Whether the schedule should re-arm after each tick. Defaults to true.</summary>
    [JsonPropertyName("recurring")]
    public bool? Recurring { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>IANA timezone for evaluating the cron expression.</summary>
    [JsonPropertyName("tz")]
    public string? Tz { get; set; }
}

/// <summary>Register an absolute-time scheduled prompt.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleAddAtRequest
{
    /// <summary>Epoch milliseconds when the prompt should fire.</summary>
    [JsonPropertyName("at")]
    public long At { get; set; }

    /// <summary>Optional display-only prompt label.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Prompt text to enqueue when the schedule fires.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Whether the schedule should re-arm after each tick. Defaults to false.</summary>
    [JsonPropertyName("recurring")]
    public bool? Recurring { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Register a self-paced scheduled prompt.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleAddSelfPacedRequest
{
    /// <summary>Optional display-only prompt label.</summary>
    [JsonPropertyName("displayPrompt")]
    public string? DisplayPrompt { get; set; }

    /// <summary>Prompt text to enqueue when the schedule fires.</summary>
    [JsonPropertyName("prompt")]
    public string Prompt { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Re-arm a self-paced scheduled prompt.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleRearmSelfPacedRequest
{
    /// <summary>Epoch milliseconds when the prompt should next fire.</summary>
    [JsonPropertyName("at")]
    public long At { get; set; }

    /// <summary>Id of the self-paced scheduled prompt.</summary>
    [JsonPropertyName("id")]
    public long Id { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Remove a scheduled prompt by id. The result entry is omitted if the id was unknown.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ScheduleStopResult
{
    /// <summary>The removed entry, or omitted if no entry matched.</summary>
    [JsonPropertyName("entry")]
    public ScheduleEntry? Entry { get; set; }
}

/// <summary>Identifier of the scheduled prompt to remove.</summary>
[Experimental(Diagnostics.Experimental)]
internal sealed class ScheduleStopRequest
{
    /// <summary>Id of the scheduled prompt to remove.</summary>
    [JsonPropertyName("id")]
    public long Id { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>A bearer token supplied by the SDK client for a BYOK provider. The runtime sets it as `Authorization: Bearer &lt;token&gt;` on the outbound request and does no caching; the SDK consumer owns token caching and refresh.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderTokenAcquireResult
{
    /// <summary>The bearer token value (without the `Bearer ` prefix).</summary>
    [JsonPropertyName("token")]
    public string Token { get; set; } = string.Empty;
}

/// <summary>Asks the SDK client to acquire a bearer token for a BYOK provider whose config set `hasBearerTokenProvider: true`. Issued by the runtime before each outbound model request; the runtime does no caching, so this is sent once per request.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderTokenAcquireRequest
{
    /// <summary>Name of the BYOK provider needing a token. For the legacy whole-session provider this is the implicit provider name; for named providers it is the configured provider name.</summary>
    [JsonPropertyName("providerName")]
    public string ProviderName { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Result returned by an extension factory closure.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryExecuteResult
{
    /// <summary>Factory result value.</summary>
    [JsonPropertyName("result")]
    public JsonElement? Result { get; set; }
}

/// <summary>Parameters sent to the owning extension to execute a factory closure.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryExecuteRequest
{
    /// <summary>Factory input value.</summary>
    [JsonPropertyName("args")]
    public JsonElement Args { get; set; }

    /// <summary>Opaque token identifying this factory execution attempt.</summary>
    [JsonPropertyName("executionToken")]
    public string ExecutionToken { get; set; } = string.Empty;

    /// <summary>Registered factory name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Parameters for cooperatively aborting a factory body.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryAbortRequest
{
    /// <summary>Opaque token identifying the execution attempt to abort.</summary>
    [JsonPropertyName("executionToken")]
    public string ExecutionToken { get; set; } = string.Empty;

    /// <summary>Factory run identifier.</summary>
    [JsonPropertyName("runId")]
    public string RunId { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Whether the client authoritatively confirmed its external work stopped.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ClientTaskCancelResult
{
    /// <summary>True only when the owner confirms that external work stopped before responding.</summary>
    [JsonPropertyName("cancelled")]
    public bool Cancelled { get; set; }
}

/// <summary>Runtime-to-owner cancellation request for a client-owned task.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ClientTaskCancelRequest
{
    /// <summary>Opaque identifier shared by coalesced cancellation callers.</summary>
    [JsonPropertyName("cancellationId")]
    public string CancellationId { get; set; } = string.Empty;

    /// <summary>Owner-scoped task key included for correlation.</summary>
    [JsonPropertyName("clientTaskId")]
    public string ClientTaskId { get; set; } = string.Empty;

    /// <summary>Canonical runtime-generated task identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Reason the runtime requests cancellation.</summary>
    [JsonPropertyName("reason")]
    public ClientTaskCancelReason Reason { get; set; }

    /// <summary>Session that owns the client task.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Describes a filesystem error.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsError
{
    /// <summary>Error classification.</summary>
    [JsonPropertyName("code")]
    public SessionFsErrorCode Code { get; set; }

    /// <summary>Free-form detail about the error, for logging/diagnostics.</summary>
    [JsonPropertyName("message")]
    public string? Message { get; set; }
}

/// <summary>File content as a UTF-8 string, or a filesystem error if the read failed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsReadFileResult
{
    /// <summary>File content as UTF-8 string.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Describes a filesystem error.</summary>
    [JsonPropertyName("error")]
    public SessionFsError? Error { get; set; }
}

/// <summary>Path of the file to read from the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsReadFileRequest
{
    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>File path, content to write, and optional mode for the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsWriteFileRequest
{
    /// <summary>Content to write.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Optional POSIX-style mode for newly created files.</summary>
    [JsonPropertyName("mode")]
    public long? Mode { get; set; }

    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>File path, content to append, and optional mode for the client-provided session filesystem. Implementations create parent directories as needed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsAppendFileRequest
{
    /// <summary>Content to append.</summary>
    [JsonPropertyName("content")]
    public string Content { get; set; } = string.Empty;

    /// <summary>Optional POSIX-style mode for newly created files.</summary>
    [JsonPropertyName("mode")]
    public long? Mode { get; set; }

    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Indicates whether the requested path exists in the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsExistsResult
{
    /// <summary>Whether the path exists.</summary>
    [JsonPropertyName("exists")]
    public bool Exists { get; set; }
}

/// <summary>Path to test for existence in the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsExistsRequest
{
    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Filesystem metadata for the requested path, or a filesystem error if the stat failed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsStatResult
{
    /// <summary>ISO 8601 timestamp of creation.</summary>
    [JsonPropertyName("birthtime")]
    public DateTimeOffset Birthtime { get; set; }

    /// <summary>Describes a filesystem error.</summary>
    [JsonPropertyName("error")]
    public SessionFsError? Error { get; set; }

    /// <summary>Whether the path is a directory.</summary>
    [JsonPropertyName("isDirectory")]
    public bool IsDirectory { get; set; }

    /// <summary>Whether the path is a file.</summary>
    [JsonPropertyName("isFile")]
    public bool IsFile { get; set; }

    /// <summary>ISO 8601 timestamp of last modification.</summary>
    [JsonPropertyName("mtime")]
    public DateTimeOffset Mtime { get; set; }

    /// <summary>File size in bytes.</summary>
    [JsonPropertyName("size")]
    public long Size { get; set; }
}

/// <summary>Path whose metadata should be returned from the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsStatRequest
{
    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Directory path to create in the client-provided session filesystem, with options for recursive creation and POSIX mode.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsMkdirRequest
{
    /// <summary>Optional POSIX-style mode for newly created directories.</summary>
    [JsonPropertyName("mode")]
    public long? Mode { get; set; }

    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Create parent directories as needed.</summary>
    [JsonPropertyName("recursive")]
    public bool? Recursive { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Names of entries in the requested directory, or a filesystem error if the read failed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsReaddirResult
{
    /// <summary>Entry names in the directory.</summary>
    [JsonPropertyName("entries")]
    public IList<string> Entries { get => field ??= []; set; }

    /// <summary>Describes a filesystem error.</summary>
    [JsonPropertyName("error")]
    public SessionFsError? Error { get; set; }
}

/// <summary>Directory path whose entries should be listed from the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsReaddirRequest
{
    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Directory entry returned by session filesystem `readdirWithTypes`, with name and entry type.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsReaddirWithTypesEntry
{
    /// <summary>Entry name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Entry type.</summary>
    [JsonPropertyName("type")]
    public SessionFsReaddirWithTypesEntryType Type { get; set; }
}

/// <summary>Entries in the requested directory paired with file/directory type information, or a filesystem error if the read failed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsReaddirWithTypesResult
{
    /// <summary>Directory entries with type information.</summary>
    [JsonPropertyName("entries")]
    public IList<SessionFsReaddirWithTypesEntry> Entries { get => field ??= []; set; }

    /// <summary>Describes a filesystem error.</summary>
    [JsonPropertyName("error")]
    public SessionFsError? Error { get; set; }
}

/// <summary>Directory path whose entries (with type information) should be listed from the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsReaddirWithTypesRequest
{
    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Path to remove from the client-provided session filesystem, with options for recursive removal and force.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsRmRequest
{
    /// <summary>Ignore errors if the path does not exist.</summary>
    [JsonPropertyName("force")]
    public bool? Force { get; set; }

    /// <summary>Path using SessionFs conventions.</summary>
    [JsonPropertyName("path")]
    public string Path { get; set; } = string.Empty;

    /// <summary>Remove directories and their contents recursively.</summary>
    [JsonPropertyName("recursive")]
    public bool? Recursive { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Source and destination paths for renaming or moving an entry in the client-provided session filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsRenameRequest
{
    /// <summary>Destination path using SessionFs conventions.</summary>
    [JsonPropertyName("dest")]
    public string Dest { get; set; } = string.Empty;

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Source path using SessionFs conventions.</summary>
    [JsonPropertyName("src")]
    public string Src { get; set; } = string.Empty;
}

/// <summary>Query results including rows, columns, and rows affected, or a filesystem error if execution failed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSqliteQueryResult
{
    /// <summary>Column names from the result set.</summary>
    [JsonPropertyName("columns")]
    public IList<string> Columns { get => field ??= []; set; }

    /// <summary>Describes a filesystem error.</summary>
    [JsonPropertyName("error")]
    public SessionFsError? Error { get; set; }

    /// <summary>SQLite last_insert_rowid() value for INSERT.</summary>
    [JsonPropertyName("lastInsertRowid")]
    public long? LastInsertRowid { get; set; }

    /// <summary>For SELECT: array of row objects. For others: empty array.</summary>
    [JsonPropertyName("rows")]
    public IList<IDictionary<string, JsonElement>> Rows { get => field ??= []; set; }

    /// <summary>Number of rows affected (for INSERT/UPDATE/DELETE).</summary>
    [JsonPropertyName("rowsAffected")]
    public long RowsAffected { get; set; }
}

/// <summary>SQL query, query type, and optional bind parameters for executing a SQLite query against the per-session database. The provider applies its SQLite busy timeout for every call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSqliteQueryRequest
{
    /// <summary>Optional named bind parameters.</summary>
    [JsonPropertyName("params")]
    public IDictionary<string, JsonElement>? Params { get; set; }

    /// <summary>SQL query to execute.</summary>
    [JsonPropertyName("query")]
    public string Query { get; set; } = string.Empty;

    /// <summary>How to execute the query: 'exec' for DDL/multi-statement (no results), 'query' for SELECT (returns rows), 'run' for INSERT/UPDATE/DELETE (returns rowsAffected).</summary>
    [JsonPropertyName("queryType")]
    public SessionFsSqliteQueryType QueryType { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Classified SQLite transaction failure. busyOrLocked guarantees rollback; postCommitAmbiguous must never be retried.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSqliteTransactionError
{
    /// <summary>Machine-readable classification of the transaction failure.</summary>
    [JsonPropertyName("errorClass")]
    public SessionFsSqliteTransactionErrorClass ErrorClass { get; set; }

    /// <summary>Human-readable transaction failure message.</summary>
    [JsonPropertyName("message")]
    public string Message { get; set; } = string.Empty;
}

/// <summary>Per-statement results, or a classified transaction error.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSqliteTransactionResult
{
    /// <summary>Classified transaction failure, when execution did not succeed.</summary>
    [JsonPropertyName("error")]
    public SessionFsSqliteTransactionError? Error { get; set; }

    /// <summary>Per-statement query results in input order.</summary>
    [JsonPropertyName("results")]
    public IList<SessionFsSqliteQueryResult> Results { get => field ??= []; set; }
}

/// <summary>One statement in an atomic SQLite transaction.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSqliteTransactionStatement
{
    /// <summary>Optional named bind parameters.</summary>
    [JsonPropertyName("params")]
    public IDictionary<string, JsonElement>? Params { get; set; }

    /// <summary>SQL statement to execute.</summary>
    [JsonPropertyName("query")]
    public string Query { get; set; } = string.Empty;

    /// <summary>How to execute the statement.</summary>
    [JsonPropertyName("queryType")]
    public SessionFsSqliteQueryType QueryType { get; set; }
}

/// <summary>Statements to execute atomically. Providers apply busy handling for every call.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSqliteTransactionRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;

    /// <summary>Ordered SQL statements to execute in one transaction.</summary>
    [JsonPropertyName("statements")]
    public IList<SessionFsSqliteTransactionStatement> Statements { get => field ??= []; set; }
}

/// <summary>Indicates whether the per-session SQLite database already exists.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SessionFsSqliteExistsResult
{
    /// <summary>Whether the session database already exists.</summary>
    [JsonPropertyName("exists")]
    public bool Exists { get; set; }
}

/// <summary>Identifies the target session.</summary>
public sealed class SessionFsSqliteExistsRequest
{
    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Canvas open result returned by the provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasProviderOpenResult
{
    /// <summary>Provider-supplied status text.</summary>
    [JsonPropertyName("status")]
    public string? Status { get; set; }

    /// <summary>Provider-supplied title.</summary>
    [JsonPropertyName("title")]
    public string? Title { get; set; }

    /// <summary>URL for web-rendered canvases.</summary>
    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>Host capabilities.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasHostContextCapabilities
{
    /// <summary>Whether canvas rendering is supported.</summary>
    [JsonPropertyName("canvases")]
    public bool? Canvases { get; set; }
}

/// <summary>Host context supplied by the runtime.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasHostContext
{
    /// <summary>Host capabilities.</summary>
    [JsonPropertyName("capabilities")]
    public CanvasHostContextCapabilities? Capabilities { get; set; }
}

/// <summary>Session context supplied by the runtime.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasSessionContext
{
    /// <summary>Active session working directory, when known.</summary>
    [JsonPropertyName("workingDirectory")]
    public string? WorkingDirectory { get; set; }
}

/// <summary>Canvas open parameters sent to the provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasProviderOpenRequest
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public string CanvasId { get; set; } = string.Empty;

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public string ExtensionId { get; set; } = string.Empty;

    /// <summary>Host context supplied by the runtime.</summary>
    [JsonPropertyName("host")]
    public CanvasHostContext? Host { get; set; }

    /// <summary>Canvas open input.</summary>
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Stable caller-supplied canvas instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public string InstanceId { get; set; } = string.Empty;

    /// <summary>Session context supplied by the runtime.</summary>
    [JsonPropertyName("session")]
    public CanvasSessionContext? Session { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Canvas close parameters sent to the provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasProviderCloseRequest
{
    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public string CanvasId { get; set; } = string.Empty;

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public string ExtensionId { get; set; } = string.Empty;

    /// <summary>Host context supplied by the runtime.</summary>
    [JsonPropertyName("host")]
    public CanvasHostContext? Host { get; set; }

    /// <summary>Canvas instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public string InstanceId { get; set; } = string.Empty;

    /// <summary>Session context supplied by the runtime.</summary>
    [JsonPropertyName("session")]
    public CanvasSessionContext? Session { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Canvas action invocation parameters sent to the provider.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasProviderInvokeActionRequest
{
    /// <summary>Action name to invoke.</summary>
    [JsonPropertyName("actionName")]
    public string ActionName { get; set; } = string.Empty;

    /// <summary>Provider-local canvas identifier.</summary>
    [JsonPropertyName("canvasId")]
    public string CanvasId { get; set; } = string.Empty;

    /// <summary>Owning provider identifier.</summary>
    [JsonPropertyName("extensionId")]
    public string ExtensionId { get; set; } = string.Empty;

    /// <summary>Host context supplied by the runtime.</summary>
    [JsonPropertyName("host")]
    public CanvasHostContext? Host { get; set; }

    /// <summary>Action input.</summary>
    [JsonPropertyName("input")]
    public JsonElement? Input { get; set; }

    /// <summary>Canvas instance identifier.</summary>
    [JsonPropertyName("instanceId")]
    public string InstanceId { get; set; } = string.Empty;

    /// <summary>Session context supplied by the runtime.</summary>
    [JsonPropertyName("session")]
    public CanvasSessionContext? Session { get; set; }

    /// <summary>Target session identifier.</summary>
    [JsonPropertyName("sessionId")]
    public string SessionId { get; set; } = string.Empty;
}

/// <summary>Opaque integrator-owned process launch profile for one extension entrypoint.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExtensionLaunchProfile
{
    /// <summary>Opaque integrator-defined arguments passed to the executable. The runtime does not append the extension entrypoint.</summary>
    [JsonPropertyName("args")]
    public IList<string> Args { get => field ??= []; set; }

    /// <summary>Opaque integrator-defined environment variables. Runtime-owned COPILOT_SDK_PATH, SESSION_ID, and COPILOT_EXTENSION_PARENT_PID values take precedence.</summary>
    [JsonPropertyName("env")]
    public IDictionary<string, string> Env { get => field ??= new Dictionary<string, string>(); set; }

    /// <summary>Executable used to launch the extension entrypoint.</summary>
    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]
    [MinLength(1)]
    [JsonPropertyName("executable")]
    public string Executable { get; set; } = string.Empty;
}

/// <summary>The launch profile for a supported entrypoint. Omit launch when the provider does not support the entrypoint.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExtensionLaunchProviderResolveResult
{
    /// <summary>Opaque launch profile, omitted when this provider does not support the entrypoint.</summary>
    [JsonPropertyName("launch")]
    public ExtensionLaunchProfile? Launch { get; set; }
}

/// <summary>A discovered extension entrypoint that the registered integrator may classify and resolve to an opaque launch profile.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExtensionLaunchProviderResolveRequest
{
    /// <summary>Source-qualified extension identifier.</summary>
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    /// <summary>Absolute path to the discovered extension entrypoint.</summary>
    [JsonPropertyName("modulePath")]
    public string ModulePath { get; set; } = string.Empty;

    /// <summary>Human-readable extension name.</summary>
    [JsonPropertyName("name")]
    public string Name { get; set; } = string.Empty;

    /// <summary>Discovery source for the extension entrypoint.</summary>
    [JsonPropertyName("source")]
    public ExtensionSource Source { get; set; }
}

/// <summary>Acknowledgement. Returning successfully simply means the SDK accepted the start frame; it does not imply the request will succeed.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceHttpRequestStartResult
{
}

/// <summary>The head of an outbound model-layer HTTP request.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceHttpRequestStartRequest
{
    /// <summary>Stable identity of the agent trajectory that issued this request. Present when the request originates from an agent turn; absent for requests outside any agent context. This is the same identity used by lifecycle and bridged session events and remains constant across turns and retries.</summary>
    [JsonPropertyName("agentId")]
    public string? AgentId { get; set; }

    /// <summary>Identity of the agent invocation (one agentic loop) that issued this request. It remains fixed across physical retries within the invocation and is distinct from the stable trajectory `agentId`. A caller-supplied invocation id always takes precedence (this covers auxiliary calls that have no model call id). Otherwise, first-party CAPI requests fall back to the runtime's agent task id — the same value the runtime emits as the `X-Agent-Task-Id` header — while custom-provider requests fall back to the model call id.</summary>
    [JsonPropertyName("agentInvocationId")]
    public string? AgentInvocationId { get; set; }

    /// <summary>HTTP request headers, preserving multiple values per name.</summary>
    [JsonPropertyName("headers")]
    public IDictionary<string, IList<string>> Headers { get => field ??= new Dictionary<string, IList<string>>(); set; }

    /// <summary>Coarse classification of the interaction that produced this request. Open string for forward-compatibility; known values include `conversation-agent`, `conversation-subagent`, `conversation-sampling`, `conversation-background`, `conversation-compaction`, and `conversation-user`. Absent when the runtime did not classify the request. Comes from the runtime's per-request agent context independently of transport; on the CAPI transport the runtime derives the upstream `X-Interaction-Type` header from this same context.</summary>
    [JsonPropertyName("interactionType")]
    public string? InteractionType { get; set; }

    /// <summary>HTTP method, e.g. GET, POST.</summary>
    [JsonPropertyName("method")]
    public string Method { get; set; } = string.Empty;

    /// <summary>Stable identity of the immediate parent trajectory. Present for child trajectories such as subagents and conversation-sampling requests; absent for root-agent and non-agent requests.</summary>
    [JsonPropertyName("parentAgentId")]
    public string? ParentAgentId { get; set; }

    /// <summary>Opaque runtime-minted id, unique per in-flight request. The SDK uses this to correlate httpRequestChunk frames and to address its httpResponseStart / httpResponseChunk replies back to the runtime.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;

    /// <summary>Id of the runtime session that triggered this request, when one is in scope. Absent for requests issued outside any session (e.g. startup model-catalog or capability resolution). This is a payload field — not a dispatch key — because the client-global API is registered process-wide rather than per session.</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }

    /// <summary>Transport the runtime would otherwise use for this request. `http` (the default when absent) covers plain HTTP and SSE responses; `websocket` indicates a full-duplex message channel where each body chunk maps to one WebSocket message and the `binary` flag distinguishes text from binary frames. The SDK consumer uses this to decide whether to service the request with an HTTP client or a WebSocket client. It is the one piece of request metadata the consumer cannot reliably infer from the URL or headers alone.</summary>
    [JsonPropertyName("transport")]
    public LlmInferenceHttpRequestStartTransport? Transport { get; set; }

    /// <summary>Absolute request URL.</summary>
    [JsonPropertyName("url")]
    public string Url { get; set; } = string.Empty;
}

/// <summary>Acknowledgement. The SDK is free to ignore the ack and treat chunk delivery as fire-and-forget.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceHttpRequestChunkResult
{
}

/// <summary>A request body chunk or cancellation signal.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LlmInferenceHttpRequestChunkRequest
{
    /// <summary>Identity of the agent invocation (one agentic loop) this body chunk belongs to, matching the `agentInvocationId` semantics on httpRequestStart. Carried per chunk so a persistent transport can attribute successive turns correctly: when a WebSocket connection is reused across turns, the httpRequestStart identity reflects only the turn that opened the connection, so each later turn stamps its own invocation id here. Absent when the runtime has no invocation context for the request, or on the plain-HTTP transport where every request has its own httpRequestStart.</summary>
    [JsonPropertyName("agentInvocationId")]
    public string? AgentInvocationId { get; set; }

    /// <summary>When true, `data` is base64-encoded bytes. When absent or false, `data` is UTF-8 text.</summary>
    [JsonPropertyName("binary")]
    public bool? Binary { get; set; }

    /// <summary>When true, the runtime is cancelling the in-flight request (e.g. upstream consumer aborted). `data` is ignored. Implies end-of-request.</summary>
    [JsonPropertyName("cancel")]
    public bool? Cancel { get; set; }

    /// <summary>Optional human-readable reason for the cancellation, propagated for logging.</summary>
    [JsonPropertyName("cancelReason")]
    public string? CancelReason { get; set; }

    /// <summary>Body byte range. UTF-8 text when `binary` is absent or false; base64-encoded bytes when `binary` is true. May be empty.</summary>
    [JsonPropertyName("data")]
    public string Data { get; set; } = string.Empty;

    /// <summary>When true, this is the final body chunk for the request. The SDK may rely on having received an end-marked chunk before treating the request body as complete.</summary>
    [JsonPropertyName("end")]
    public bool? End { get; set; }

    /// <summary>Matches the requestId from the originating httpRequestStart frame.</summary>
    [JsonPropertyName("requestId")]
    public string RequestId { get; set; } = string.Empty;
}

/// <summary>Client environment metadata describing the process that produced a telemetry event.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class GitHubTelemetryClientInfo
{
    /// <summary>Copilot CLI version string.</summary>
    [JsonPropertyName("cli_version")]
    public string CliVersion { get; set; } = string.Empty;

    /// <summary>Name of the client application.</summary>
    [JsonPropertyName("client_name")]
    public string? ClientName { get; set; }

    /// <summary>Type of client.</summary>
    [JsonPropertyName("client_type")]
    public string? ClientType { get; set; }

    /// <summary>Copilot subscription plan, when known.</summary>
    [JsonPropertyName("copilot_plan")]
    public string? CopilotPlan { get; set; }

    /// <summary>Number of logical CPU cores on the host.</summary>
    [JsonPropertyName("cpu_count")]
    public long? CpuCount { get; set; }

    /// <summary>Distinct CPU model names for the host, comma-separated.</summary>
    [JsonPropertyName("cpu_model")]
    public string? CpuModel { get; set; }

    /// <summary>Stable machine identifier for the device.</summary>
    [JsonPropertyName("dev_device_id")]
    public string? DevDeviceId { get; set; }

    /// <summary>Whether the user is a GitHub/Microsoft staff member.</summary>
    [JsonPropertyName("is_staff")]
    public bool? IsStaff { get; set; }

    /// <summary>Node.js runtime version string.</summary>
    [JsonPropertyName("node_version")]
    public string NodeVersion { get; set; } = string.Empty;

    /// <summary>Operating system architecture (e.g. arm64, x64).</summary>
    [JsonPropertyName("os_arch")]
    public string OsArch { get; set; } = string.Empty;

    /// <summary>Operating system platform (e.g. darwin, linux, win32).</summary>
    [JsonPropertyName("os_platform")]
    public string OsPlatform { get; set; } = string.Empty;

    /// <summary>Operating system version string.</summary>
    [JsonPropertyName("os_version")]
    public string OsVersion { get; set; } = string.Empty;
}

/// <summary>A single telemetry event in the runtime's native GitHub-shaped telemetry format, forwarded verbatim to opted-in hosts. The `restricted` flag on the enclosing GitHubTelemetryNotification distinguishes standard from restricted events; the payload shape is identical for both.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class GitHubTelemetryEvent
{
    /// <summary>Client environment metadata.</summary>
    [JsonPropertyName("client")]
    public GitHubTelemetryClientInfo? Client { get; set; }

    /// <summary>Copilot tracking ID for user-level attribution.</summary>
    [JsonPropertyName("copilot_tracking_id")]
    public string? CopilotTrackingId { get; set; }

    /// <summary>Timestamp when the event was created (ISO 8601 format).</summary>
    [JsonPropertyName("created_at")]
    public string? CreatedAt { get; set; }

    /// <summary>Experiment assignment context.</summary>
    [JsonPropertyName("exp_assignment_context")]
    public string? ExpAssignmentContext { get; set; }

    /// <summary>Feature flags enabled for this session, as a map from flag to value.</summary>
    [JsonPropertyName("features")]
    public IDictionary<string, string>? Features { get; set; }

    /// <summary>Event type/kind (e.g. get_completion_with_tools_turn, tool_call_executed).</summary>
    [JsonPropertyName("kind")]
    public string Kind { get; set; } = string.Empty;

    /// <summary>Numeric metrics as a map from key to value.</summary>
    [JsonPropertyName("metrics")]
    public IDictionary<string, double> Metrics { get => field ??= new Dictionary<string, double>(); set; }

    /// <summary>Reference to the model call that produced this event.</summary>
    [JsonPropertyName("model_call_id")]
    public string? ModelCallId { get; set; }

    /// <summary>String-valued properties as a map from key to value.</summary>
    [JsonPropertyName("properties")]
    public IDictionary<string, string> Properties { get => field ??= new Dictionary<string, string>(); set; }

    /// <summary>Session identifier the event belongs to.</summary>
    [JsonPropertyName("session_id")]
    public string? SessionId { get; set; }
}

/// <summary>Payload for a `gitHubTelemetry.event` notification: a single GitHub telemetry event the runtime forwards to a host connection that opted into telemetry forwarding during the `server.connect` handshake.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class GitHubTelemetryNotification
{
    /// <summary>The telemetry event, in the runtime's native GitHub-shaped telemetry format.</summary>
    [JsonPropertyName("event")]
    public GitHubTelemetryEvent Event { get => field ??= new(); set; }

    /// <summary>Whether this is a restricted telemetry event (cli.restricted_telemetry). Hosts must route restricted events to first-party Microsoft stores only.</summary>
    [JsonPropertyName("restricted")]
    public bool Restricted { get; set; }

    /// <summary>Session the telemetry event belongs to, when it is session-scoped. Omitted for sessionless events (for example, `server.sendTelemetry` calls with no session id), which are still forwarded to opted-in connections.</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }
}

/// <summary>SDK host response to a GitHub credential request.</summary>
/// <remarks>Polymorphic base type discriminated by <c>kind</c>.</remarks>
[Experimental(Diagnostics.Experimental)]
[JsonPolymorphic(
    TypeDiscriminatorPropertyName = "kind",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType)]
[JsonDerivedType(typeof(GitHubTokenAcquireResultToken), "token")]
[JsonDerivedType(typeof(GitHubTokenAcquireResultCancelled), "cancelled")]
public partial class GitHubTokenAcquireResult
{
    /// <summary>The type discriminator.</summary>
    [JsonPropertyName("kind")]
    public virtual string Kind { get; set; } = string.Empty;
}


/// <summary>The <c>token</c> variant of <see cref="GitHubTokenAcquireResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class GitHubTokenAcquireResultToken : GitHubTokenAcquireResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "token";

    /// <summary>GitHub access token acquired by the SDK host.</summary>
    [JsonPropertyName("accessToken")]
    public required string AccessToken { get; set; }

    /// <summary>Remaining token lifetime in seconds when callback execution completes. It must exceed the one-hour preflight refresh threshold.</summary>
    [JsonPropertyName("expiresIn")]
    public required long ExpiresIn { get; set; }

    /// <summary>OAuth token type. Defaults to bearer when omitted.</summary>
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonPropertyName("tokenType")]
    public string? TokenType { get; set; }
}

/// <summary>The <c>cancelled</c> variant of <see cref="GitHubTokenAcquireResult"/>.</summary>
[Experimental(Diagnostics.Experimental)]
public partial class GitHubTokenAcquireResultCancelled : GitHubTokenAcquireResult
{
    /// <inheritdoc />
    [JsonIgnore]
    public override string Kind => "cancelled";
}

/// <summary>Asks the SDK client to acquire a GitHub access token from an opaque callback registration.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class GitHubTokenAcquireRequest
{
    /// <summary>Effective GitHub host for which the callback must return a token.</summary>
    [JsonPropertyName("host")]
    public string Host { get; set; } = string.Empty;

    /// <summary>Why the runtime is requesting a GitHub credential.</summary>
    [JsonPropertyName("reason")]
    public GitHubTokenAcquireReason Reason { get; set; }

    /// <summary>Opaque identifier generated by the SDK for this callback registration.</summary>
    [JsonPropertyName("registrationId")]
    public string RegistrationId { get; set; } = string.Empty;

    /// <summary>Session receiving the token. Absent only before a cloud session has been assigned its id.</summary>
    [JsonPropertyName("sessionId")]
    public string? SessionId { get; set; }
}

/// <summary>Closed set of public task kinds a connection can negotiate.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskKind : IEquatable<TaskKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskKind"/>.</param>
    [JsonConstructor]
    public TaskKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Runtime-owned background agent task.</summary>
    public static TaskKind Agent { get; } = new("agent");

    /// <summary>Runtime-owned shell task.</summary>
    public static TaskKind Shell { get; } = new("shell");

    /// <summary>Client-owned externally executed task.</summary>
    public static TaskKind Client { get; } = new("client");

    /// <summary>Returns a value indicating whether two <see cref="TaskKind"/> instances are equivalent.</summary>
    public static bool operator ==(TaskKind left, TaskKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskKind"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskKind left, TaskKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskKind}"/> for serializing <see cref="TaskKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskKind>
    {
        /// <inheritdoc />
        public override TaskKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskKind));
        }
    }
}


/// <summary>Hook event name. Discovery emits the file-configurable subset; SDK callbacks additionally support callback-only events.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HookType : IEquatable<HookType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HookType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HookType"/>.</param>
    [JsonConstructor]
    public HookType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HookType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Runs before a tool is invoked.</summary>
    public static HookType PreToolUse { get; } = new("preToolUse");

    /// <summary>Runs before an MCP tool is invoked.</summary>
    public static HookType PreMcpToolCall { get; } = new("preMcpToolCall");

    /// <summary>Runs after a tool completes successfully.</summary>
    public static HookType PostToolUse { get; } = new("postToolUse");

    /// <summary>Runs after a tool fails.</summary>
    public static HookType PostToolUseFailure { get; } = new("postToolUseFailure");

    /// <summary>Runs after the user submits a prompt.</summary>
    public static HookType UserPromptSubmitted { get; } = new("userPromptSubmitted");

    /// <summary>Runs after the runtime transforms the submitted prompt for the model, before it is added to session history.</summary>
    public static HookType UserPromptTransformed { get; } = new("userPromptTransformed");

    /// <summary>Runs when a session starts.</summary>
    public static HookType SessionStart { get; } = new("sessionStart");

    /// <summary>Runs when a session ends.</summary>
    public static HookType SessionEnd { get; } = new("sessionEnd");

    /// <summary>Runs after an agent result is produced.</summary>
    public static HookType PostResult { get; } = new("postResult");

    /// <summary>Runs before a pull request description is generated.</summary>
    public static HookType PrePRDescription { get; } = new("prePRDescription");

    /// <summary>Runs when the agent encounters an error.</summary>
    public static HookType ErrorOccurred { get; } = new("errorOccurred");

    /// <summary>Runs when the agent stops.</summary>
    public static HookType AgentStop { get; } = new("agentStop");

    /// <summary>Runs when a subagent starts.</summary>
    public static HookType SubagentStart { get; } = new("subagentStart");

    /// <summary>Runs when a subagent stops.</summary>
    public static HookType SubagentStop { get; } = new("subagentStop");

    /// <summary>Runs before conversation context is compacted.</summary>
    public static HookType PreCompact { get; } = new("preCompact");

    /// <summary>Runs when the agent requests permission.</summary>
    public static HookType PermissionRequest { get; } = new("permissionRequest");

    /// <summary>Runs when the agent emits a notification.</summary>
    public static HookType Notification { get; } = new("notification");

    /// <summary>Returns a value indicating whether two <see cref="HookType"/> instances are equivalent.</summary>
    public static bool operator ==(HookType left, HookType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HookType"/> instances are not equivalent.</summary>
    public static bool operator !=(HookType left, HookType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HookType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HookType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HookType}"/> for serializing <see cref="HookType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HookType>
    {
        /// <inheritdoc />
        public override HookType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HookType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HookType));
        }
    }
}


/// <summary>Configuration tier that contributed a discovered hook action.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HookOrigin : IEquatable<HookOrigin>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HookOrigin"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HookOrigin"/>.</param>
    [JsonConstructor]
    public HookOrigin(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HookOrigin"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Hook loaded from user settings or the user's hook directory.</summary>
    public static HookOrigin User { get; } = new("user");

    /// <summary>Hook loaded from repository settings or the repository hook directory.</summary>
    public static HookOrigin Repository { get; } = new("repository");

    /// <summary>Hook provided by an enabled installed or explicit plugin. Projectless rows omit projectPath and do not expand a project directory.</summary>
    public static HookOrigin Plugin { get; } = new("plugin");

    /// <summary>Hook enforced by centrally managed policy.</summary>
    public static HookOrigin Policy { get; } = new("policy");

    /// <summary>Returns a value indicating whether two <see cref="HookOrigin"/> instances are equivalent.</summary>
    public static bool operator ==(HookOrigin left, HookOrigin right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HookOrigin"/> instances are not equivalent.</summary>
    public static bool operator !=(HookOrigin left, HookOrigin right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HookOrigin other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HookOrigin other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HookOrigin}"/> for serializing <see cref="HookOrigin"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HookOrigin>
    {
        /// <inheritdoc />
        public override HookOrigin Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HookOrigin value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HookOrigin));
        }
    }
}


/// <summary>Resolved Anthropic adaptive-thinking capability for a model.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AdaptiveThinkingSupport : IEquatable<AdaptiveThinkingSupport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AdaptiveThinkingSupport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AdaptiveThinkingSupport"/>.</param>
    [JsonConstructor]
    public AdaptiveThinkingSupport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AdaptiveThinkingSupport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The model does not accept thinking.type='adaptive'.</summary>
    public static AdaptiveThinkingSupport Unsupported { get; } = new("unsupported");

    /// <summary>The model accepts adaptive thinking but also accepts thinking.type='enabled'.</summary>
    public static AdaptiveThinkingSupport Optional { get; } = new("optional");

    /// <summary>The model only accepts adaptive thinking and rejects thinking.type='enabled' with HTTP 400 (e.g. opus-4.7/4.8).</summary>
    public static AdaptiveThinkingSupport Required { get; } = new("required");

    /// <summary>Returns a value indicating whether two <see cref="AdaptiveThinkingSupport"/> instances are equivalent.</summary>
    public static bool operator ==(AdaptiveThinkingSupport left, AdaptiveThinkingSupport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AdaptiveThinkingSupport"/> instances are not equivalent.</summary>
    public static bool operator !=(AdaptiveThinkingSupport left, AdaptiveThinkingSupport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AdaptiveThinkingSupport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AdaptiveThinkingSupport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AdaptiveThinkingSupport}"/> for serializing <see cref="AdaptiveThinkingSupport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AdaptiveThinkingSupport>
    {
        /// <inheritdoc />
        public override AdaptiveThinkingSupport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AdaptiveThinkingSupport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AdaptiveThinkingSupport));
        }
    }
}


/// <summary>Model capability category for grouping in the model picker.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelPickerCategory : IEquatable<ModelPickerCategory>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelPickerCategory"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelPickerCategory"/>.</param>
    [JsonConstructor]
    public ModelPickerCategory(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelPickerCategory"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Lightweight model category optimized for faster, lower-cost interactions.</summary>
    public static ModelPickerCategory Lightweight { get; } = new("lightweight");

    /// <summary>Versatile model category suitable for a broad range of tasks.</summary>
    public static ModelPickerCategory Versatile { get; } = new("versatile");

    /// <summary>Powerful model category optimized for complex tasks.</summary>
    public static ModelPickerCategory Powerful { get; } = new("powerful");

    /// <summary>Returns a value indicating whether two <see cref="ModelPickerCategory"/> instances are equivalent.</summary>
    public static bool operator ==(ModelPickerCategory left, ModelPickerCategory right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelPickerCategory"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelPickerCategory left, ModelPickerCategory right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelPickerCategory other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelPickerCategory other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelPickerCategory}"/> for serializing <see cref="ModelPickerCategory"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelPickerCategory>
    {
        /// <inheritdoc />
        public override ModelPickerCategory Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelPickerCategory value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelPickerCategory));
        }
    }
}


/// <summary>Relative cost tier for token-based billing users.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelPickerPriceCategory : IEquatable<ModelPickerPriceCategory>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelPickerPriceCategory"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelPickerPriceCategory"/>.</param>
    [JsonConstructor]
    public ModelPickerPriceCategory(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelPickerPriceCategory"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Lowest relative token cost tier.</summary>
    public static ModelPickerPriceCategory Low { get; } = new("low");

    /// <summary>Medium relative token cost tier.</summary>
    public static ModelPickerPriceCategory Medium { get; } = new("medium");

    /// <summary>High relative token cost tier.</summary>
    public static ModelPickerPriceCategory High { get; } = new("high");

    /// <summary>Highest relative token cost tier.</summary>
    public static ModelPickerPriceCategory VeryHigh { get; } = new("very_high");

    /// <summary>Returns a value indicating whether two <see cref="ModelPickerPriceCategory"/> instances are equivalent.</summary>
    public static bool operator ==(ModelPickerPriceCategory left, ModelPickerPriceCategory right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelPickerPriceCategory"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelPickerPriceCategory left, ModelPickerPriceCategory right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelPickerPriceCategory other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelPickerPriceCategory other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelPickerPriceCategory}"/> for serializing <see cref="ModelPickerPriceCategory"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelPickerPriceCategory>
    {
        /// <inheritdoc />
        public override ModelPickerPriceCategory Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelPickerPriceCategory value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelPickerPriceCategory));
        }
    }
}


/// <summary>Current policy state for this model.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelPolicyState : IEquatable<ModelPolicyState>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelPolicyState"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelPolicyState"/>.</param>
    [JsonConstructor]
    public ModelPolicyState(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelPolicyState"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The model is enabled by policy.</summary>
    public static ModelPolicyState Enabled { get; } = new("enabled");

    /// <summary>The model is disabled by policy.</summary>
    public static ModelPolicyState Disabled { get; } = new("disabled");

    /// <summary>No explicit policy is configured for the model.</summary>
    public static ModelPolicyState Unconfigured { get; } = new("unconfigured");

    /// <summary>Returns a value indicating whether two <see cref="ModelPolicyState"/> instances are equivalent.</summary>
    public static bool operator ==(ModelPolicyState left, ModelPolicyState right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelPolicyState"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelPolicyState left, ModelPolicyState right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelPolicyState other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelPolicyState other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelPolicyState}"/> for serializing <see cref="ModelPolicyState"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelPolicyState>
    {
        /// <inheritdoc />
        public override ModelPolicyState Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelPolicyState value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelPolicyState));
        }
    }
}


/// <summary>Server transport type: stdio, http, sse (deprecated), or memory.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct DiscoveredMcpServerType : IEquatable<DiscoveredMcpServerType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="DiscoveredMcpServerType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="DiscoveredMcpServerType"/>.</param>
    [JsonConstructor]
    public DiscoveredMcpServerType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="DiscoveredMcpServerType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Server communicates over stdio with a local child process.</summary>
    public static DiscoveredMcpServerType Stdio { get; } = new("stdio");

    /// <summary>Server communicates over streamable HTTP.</summary>
    public static DiscoveredMcpServerType Http { get; } = new("http");

    /// <summary>Server communicates over Server-Sent Events (deprecated).</summary>
    public static DiscoveredMcpServerType Sse { get; } = new("sse");

    /// <summary>Server is backed by an in-memory runtime implementation.</summary>
    public static DiscoveredMcpServerType Memory { get; } = new("memory");

    /// <summary>Returns a value indicating whether two <see cref="DiscoveredMcpServerType"/> instances are equivalent.</summary>
    public static bool operator ==(DiscoveredMcpServerType left, DiscoveredMcpServerType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="DiscoveredMcpServerType"/> instances are not equivalent.</summary>
    public static bool operator !=(DiscoveredMcpServerType left, DiscoveredMcpServerType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is DiscoveredMcpServerType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(DiscoveredMcpServerType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{DiscoveredMcpServerType}"/> for serializing <see cref="DiscoveredMcpServerType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<DiscoveredMcpServerType>
    {
        /// <inheritdoc />
        public override DiscoveredMcpServerType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, DiscoveredMcpServerType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(DiscoveredMcpServerType));
        }
    }
}


/// <summary>A wire feature a caller can require of the catalog surface, negotiated per request. A grant means the runtime understands the feature's contract, not that the deployment has enabled the operation; typed unavailable results report availability separately.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogCapability : IEquatable<CatalogCapability>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogCapability"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogCapability"/>.</param>
    [JsonConstructor]
    public CatalogCapability(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogCapability"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Understands the current `application/mcp-server-card+json` media type.</summary>
    public static CatalogCapability McpServerCard { get; } = new("mcp-server-card");

    /// <summary>Understands the legacy `application/mcp-server+json` media type.</summary>
    public static CatalogCapability LegacyMcpServerCard { get; } = new("legacy-mcp-server-card");

    /// <summary>Understands `application/ai-skill` candidates as discovery-only and typed non-installable.</summary>
    public static CatalogCapability AiSkillDiscovery { get; } = new("ai-skill-discovery");

    /// <summary>Understands side-effect-free MCP install-plan requests, results, and plan handles; `planning-unavailable` separately reports that planning is not enabled.</summary>
    public static CatalogCapability McpInstallPlanning { get; } = new("mcp-install-planning");

    /// <summary>Understands plans that enumerate every eligible transport rather than a single preferred one.</summary>
    public static CatalogCapability MultipleTransportChoice { get; } = new("multiple-transport-choice");

    /// <summary>Returns a value indicating whether two <see cref="CatalogCapability"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogCapability left, CatalogCapability right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogCapability"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogCapability left, CatalogCapability right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogCapability other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogCapability other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogCapability}"/> for serializing <see cref="CatalogCapability"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogCapability>
    {
        /// <inheritdoc />
        public override CatalogCapability Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogCapability value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogCapability));
        }
    }
}


/// <summary>Whether a planned configuration change would create or modify an entry.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanConfigurationOperation : IEquatable<McpPlanConfigurationOperation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanConfigurationOperation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanConfigurationOperation"/>.</param>
    [JsonConstructor]
    public McpPlanConfigurationOperation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanConfigurationOperation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Creates a configuration entry that does not exist yet.</summary>
    public static McpPlanConfigurationOperation Add { get; } = new("add");

    /// <summary>Modifies a configuration entry that already exists.</summary>
    public static McpPlanConfigurationOperation Update { get; } = new("update");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanConfigurationOperation"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanConfigurationOperation left, McpPlanConfigurationOperation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanConfigurationOperation"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanConfigurationOperation left, McpPlanConfigurationOperation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanConfigurationOperation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanConfigurationOperation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanConfigurationOperation}"/> for serializing <see cref="McpPlanConfigurationOperation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanConfigurationOperation>
    {
        /// <inheritdoc />
        public override McpPlanConfigurationOperation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanConfigurationOperation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanConfigurationOperation));
        }
    }
}


/// <summary>Configuration scope an MCP install plan targets.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanScope : IEquatable<McpPlanScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanScope"/>.</param>
    [JsonConstructor]
    public McpPlanScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The user's own MCP configuration.</summary>
    public static McpPlanScope User { get; } = new("user");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanScope"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanScope left, McpPlanScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanScope"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanScope left, McpPlanScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanScope}"/> for serializing <see cref="McpPlanScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanScope>
    {
        /// <inheritdoc />
        public override McpPlanScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanScope));
        }
    }
}


/// <summary>What policy decided for a planned server.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanPolicyDecision : IEquatable<McpPlanPolicyDecision>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanPolicyDecision"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanPolicyDecision"/>.</param>
    [JsonConstructor]
    public McpPlanPolicyDecision(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanPolicyDecision"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Policy permits the server.</summary>
    public static McpPlanPolicyDecision Allowed { get; } = new("allowed");

    /// <summary>Policy forbids the server, so the plan cannot be applied.</summary>
    public static McpPlanPolicyDecision Blocked { get; } = new("blocked");

    /// <summary>Policy permits the server only after an explicit approval.</summary>
    public static McpPlanPolicyDecision RequiresApproval { get; } = new("requires-approval");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanPolicyDecision"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanPolicyDecision left, McpPlanPolicyDecision right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanPolicyDecision"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanPolicyDecision left, McpPlanPolicyDecision right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanPolicyDecision other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanPolicyDecision other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanPolicyDecision}"/> for serializing <see cref="McpPlanPolicyDecision"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanPolicyDecision>
    {
        /// <inheritdoc />
        public override McpPlanPolicyDecision Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanPolicyDecision value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanPolicyDecision));
        }
    }
}


/// <summary>Which authority produced a policy decision.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanPolicySource : IEquatable<McpPlanPolicySource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanPolicySource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanPolicySource"/>.</param>
    [JsonConstructor]
    public McpPlanPolicySource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanPolicySource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>No policy applied, so the server is permitted by default.</summary>
    public static McpPlanPolicySource None { get; } = new("none");

    /// <summary>An enterprise allowlist evaluated the server.</summary>
    public static McpPlanPolicySource EnterpriseAllowlist { get; } = new("enterprise-allowlist");

    /// <summary>The registry the card came from evaluated the server.</summary>
    public static McpPlanPolicySource RegistryPolicy { get; } = new("registry-policy");

    /// <summary>Local trust settings evaluated the server.</summary>
    public static McpPlanPolicySource LocalTrust { get; } = new("local-trust");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanPolicySource"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanPolicySource left, McpPlanPolicySource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanPolicySource"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanPolicySource left, McpPlanPolicySource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanPolicySource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanPolicySource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanPolicySource}"/> for serializing <see cref="McpPlanPolicySource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanPolicySource>
    {
        /// <inheritdoc />
        public override McpPlanPolicySource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanPolicySource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanPolicySource));
        }
    }
}


/// <summary>Canonical digest algorithm for a validated MCP card.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CardDigestAlgorithm : IEquatable<CardDigestAlgorithm>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CardDigestAlgorithm"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CardDigestAlgorithm"/>.</param>
    [JsonConstructor]
    public CardDigestAlgorithm(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CardDigestAlgorithm"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>SHA-256 over RFC 8785 canonical JSON encoded as UTF-8.</summary>
    public static CardDigestAlgorithm Sha256Rfc8785 { get; } = new("sha256-rfc8785");

    /// <summary>Returns a value indicating whether two <see cref="CardDigestAlgorithm"/> instances are equivalent.</summary>
    public static bool operator ==(CardDigestAlgorithm left, CardDigestAlgorithm right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CardDigestAlgorithm"/> instances are not equivalent.</summary>
    public static bool operator !=(CardDigestAlgorithm left, CardDigestAlgorithm right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CardDigestAlgorithm other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CardDigestAlgorithm other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CardDigestAlgorithm}"/> for serializing <see cref="CardDigestAlgorithm"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CardDigestAlgorithm>
    {
        /// <inheritdoc />
        public override CardDigestAlgorithm Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CardDigestAlgorithm value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CardDigestAlgorithm));
        }
    }
}


/// <summary>JSON MCP card media type accepted for install planning.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpServerCardMediaType : IEquatable<McpServerCardMediaType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpServerCardMediaType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpServerCardMediaType"/>.</param>
    [JsonConstructor]
    public McpServerCardMediaType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpServerCardMediaType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The current MCP server card media type.</summary>
    public static McpServerCardMediaType ApplicationMcpServerCardJson { get; } = new("application/mcp-server-card+json");

    /// <summary>The legacy MCP server card media type, accepted for compatibility.</summary>
    public static McpServerCardMediaType ApplicationMcpServerJson { get; } = new("application/mcp-server+json");

    /// <summary>Returns a value indicating whether two <see cref="McpServerCardMediaType"/> instances are equivalent.</summary>
    public static bool operator ==(McpServerCardMediaType left, McpServerCardMediaType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpServerCardMediaType"/> instances are not equivalent.</summary>
    public static bool operator !=(McpServerCardMediaType left, McpServerCardMediaType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpServerCardMediaType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpServerCardMediaType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpServerCardMediaType}"/> for serializing <see cref="McpServerCardMediaType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpServerCardMediaType>
    {
        /// <inheritdoc />
        public override McpServerCardMediaType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpServerCardMediaType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpServerCardMediaType));
        }
    }
}


/// <summary>Where a required value is applied when the planned server is launched.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanValueCategory : IEquatable<McpPlanValueCategory>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanValueCategory"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanValueCategory"/>.</param>
    [JsonConstructor]
    public McpPlanValueCategory(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanValueCategory"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Set as an environment variable on the launched process.</summary>
    public static McpPlanValueCategory EnvironmentVariable { get; } = new("environment-variable");

    /// <summary>Passed to the runtime that launches the package.</summary>
    public static McpPlanValueCategory RuntimeArgument { get; } = new("runtime-argument");

    /// <summary>Passed to the packaged server itself.</summary>
    public static McpPlanValueCategory PackageArgument { get; } = new("package-argument");

    /// <summary>Sent as a request header to a remote endpoint.</summary>
    public static McpPlanValueCategory Header { get; } = new("header");

    /// <summary>Substituted into the remote endpoint URL.</summary>
    public static McpPlanValueCategory UrlVariable { get; } = new("url-variable");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanValueCategory"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanValueCategory left, McpPlanValueCategory right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanValueCategory"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanValueCategory left, McpPlanValueCategory right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanValueCategory other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanValueCategory other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanValueCategory}"/> for serializing <see cref="McpPlanValueCategory"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanValueCategory>
    {
        /// <inheritdoc />
        public override McpPlanValueCategory Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanValueCategory value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanValueCategory));
        }
    }
}


/// <summary>Scalar type a required value must conform to.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanScalarValueType : IEquatable<McpPlanScalarValueType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanScalarValueType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanScalarValueType"/>.</param>
    [JsonConstructor]
    public McpPlanScalarValueType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanScalarValueType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Free text.</summary>
    public static McpPlanScalarValueType String { get; } = new("string");

    /// <summary>A number.</summary>
    public static McpPlanScalarValueType Number { get; } = new("number");

    /// <summary>A boolean.</summary>
    public static McpPlanScalarValueType Boolean { get; } = new("boolean");

    /// <summary>A filesystem path.</summary>
    public static McpPlanScalarValueType Path { get; } = new("path");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanScalarValueType"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanScalarValueType left, McpPlanScalarValueType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanScalarValueType"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanScalarValueType left, McpPlanScalarValueType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanScalarValueType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanScalarValueType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanScalarValueType}"/> for serializing <see cref="McpPlanScalarValueType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanScalarValueType>
    {
        /// <inheritdoc />
        public override McpPlanScalarValueType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanScalarValueType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanScalarValueType));
        }
    }
}


/// <summary>Discriminator for an enumerated required value.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanEnumValueType : IEquatable<McpPlanEnumValueType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanEnumValueType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanEnumValueType"/>.</param>
    [JsonConstructor]
    public McpPlanEnumValueType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanEnumValueType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>One of a fixed, non-empty set of permitted values.</summary>
    public static McpPlanEnumValueType Enum { get; } = new("enum");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanEnumValueType"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanEnumValueType left, McpPlanEnumValueType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanEnumValueType"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanEnumValueType left, McpPlanEnumValueType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanEnumValueType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanEnumValueType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanEnumValueType}"/> for serializing <see cref="McpPlanEnumValueType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanEnumValueType>
    {
        /// <inheritdoc />
        public override McpPlanEnumValueType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanEnumValueType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanEnumValueType));
        }
    }
}


/// <summary>Transport exposed by a locally launched package.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanPackageTransport : IEquatable<McpPlanPackageTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanPackageTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanPackageTransport"/>.</param>
    [JsonConstructor]
    public McpPlanPackageTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanPackageTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A locally launched process spoken to over standard input and output.</summary>
    public static McpPlanPackageTransport Stdio { get; } = new("stdio");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanPackageTransport"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanPackageTransport left, McpPlanPackageTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanPackageTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanPackageTransport left, McpPlanPackageTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanPackageTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanPackageTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanPackageTransport}"/> for serializing <see cref="McpPlanPackageTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanPackageTransport>
    {
        /// <inheritdoc />
        public override McpPlanPackageTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanPackageTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanPackageTransport));
        }
    }
}


/// <summary>Transport exposed by a remote endpoint.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpPlanRemoteTransport : IEquatable<McpPlanRemoteTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpPlanRemoteTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpPlanRemoteTransport"/>.</param>
    [JsonConstructor]
    public McpPlanRemoteTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpPlanRemoteTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>An HTTP endpoint.</summary>
    public static McpPlanRemoteTransport Http { get; } = new("http");

    /// <summary>A streamable HTTP endpoint.</summary>
    public static McpPlanRemoteTransport StreamableHttp { get; } = new("streamable-http");

    /// <summary>A server-sent events endpoint.</summary>
    public static McpPlanRemoteTransport Sse { get; } = new("sse");

    /// <summary>Returns a value indicating whether two <see cref="McpPlanRemoteTransport"/> instances are equivalent.</summary>
    public static bool operator ==(McpPlanRemoteTransport left, McpPlanRemoteTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpPlanRemoteTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(McpPlanRemoteTransport left, McpPlanRemoteTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpPlanRemoteTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpPlanRemoteTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpPlanRemoteTransport}"/> for serializing <see cref="McpPlanRemoteTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpPlanRemoteTransport>
    {
        /// <inheritdoc />
        public override McpPlanRemoteTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpPlanRemoteTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpPlanRemoteTransport));
        }
    }
}


/// <summary>Why capability and protocol-version negotiation refused a caller.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogNegotiationRefusedReason : IEquatable<CatalogNegotiationRefusedReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogNegotiationRefusedReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogNegotiationRefusedReason"/>.</param>
    [JsonConstructor]
    public CatalogNegotiationRefusedReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogNegotiationRefusedReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The caller's protocol version is below the lowest this runtime serves.</summary>
    public static CatalogNegotiationRefusedReason UnsupportedProtocolVersion { get; } = new("unsupported-protocol-version");

    /// <summary>The caller requires at least one capability this runtime cannot honour.</summary>
    public static CatalogNegotiationRefusedReason UnsupportedCapability { get; } = new("unsupported-capability");

    /// <summary>Returns a value indicating whether two <see cref="CatalogNegotiationRefusedReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogNegotiationRefusedReason left, CatalogNegotiationRefusedReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogNegotiationRefusedReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogNegotiationRefusedReason left, CatalogNegotiationRefusedReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogNegotiationRefusedReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogNegotiationRefusedReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogNegotiationRefusedReason}"/> for serializing <see cref="CatalogNegotiationRefusedReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogNegotiationRefusedReason>
    {
        /// <inheritdoc />
        public override CatalogNegotiationRefusedReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogNegotiationRefusedReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogNegotiationRefusedReason));
        }
    }
}


/// <summary>Which kind of opaque handle was presented.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogHandleType : IEquatable<CatalogHandleType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogHandleType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogHandleType"/>.</param>
    [JsonConstructor]
    public CatalogHandleType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogHandleType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A search candidate handle.</summary>
    public static CatalogHandleType Candidate { get; } = new("candidate");

    /// <summary>An install plan handle.</summary>
    public static CatalogHandleType Plan { get; } = new("plan");

    /// <summary>Returns a value indicating whether two <see cref="CatalogHandleType"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogHandleType left, CatalogHandleType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogHandleType"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogHandleType left, CatalogHandleType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogHandleType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogHandleType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogHandleType}"/> for serializing <see cref="CatalogHandleType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogHandleType>
    {
        /// <inheritdoc />
        public override CatalogHandleType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogHandleType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogHandleType));
        }
    }
}


/// <summary>Why a presented handle was rejected.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogHandleRejectionReason : IEquatable<CatalogHandleRejectionReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogHandleRejectionReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogHandleRejectionReason"/>.</param>
    [JsonConstructor]
    public CatalogHandleRejectionReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogHandleRejectionReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The handle is unparseable, unknown, or was issued for a different operation.</summary>
    public static CatalogHandleRejectionReason Invalid { get; } = new("invalid");

    /// <summary>The handle's time to live has elapsed.</summary>
    public static CatalogHandleRejectionReason Stale { get; } = new("stale");

    /// <summary>The handle has already been used, and handles are single-use.</summary>
    public static CatalogHandleRejectionReason Replayed { get; } = new("replayed");

    /// <summary>The handle was issued by a different runtime instance.</summary>
    public static CatalogHandleRejectionReason Foreign { get; } = new("foreign");

    /// <summary>Returns a value indicating whether two <see cref="CatalogHandleRejectionReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogHandleRejectionReason left, CatalogHandleRejectionReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogHandleRejectionReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogHandleRejectionReason left, CatalogHandleRejectionReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogHandleRejectionReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogHandleRejectionReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogHandleRejectionReason}"/> for serializing <see cref="CatalogHandleRejectionReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogHandleRejectionReason>
    {
        /// <inheritdoc />
        public override CatalogHandleRejectionReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogHandleRejectionReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogHandleRejectionReason));
        }
    }
}


/// <summary>Which request field was rejected before any work was done.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogInvalidRequestField : IEquatable<CatalogInvalidRequestField>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogInvalidRequestField"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogInvalidRequestField"/>.</param>
    [JsonConstructor]
    public CatalogInvalidRequestField(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogInvalidRequestField"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The search query was empty or longer than permitted.</summary>
    public static CatalogInvalidRequestField Query { get; } = new("query");

    /// <summary>The requested result count fell outside its permitted range.</summary>
    public static CatalogInvalidRequestField Limit { get; } = new("limit");

    /// <summary>The requested candidate kinds were empty or contained a duplicate.</summary>
    public static CatalogInvalidRequestField Kinds { get; } = new("kinds");

    /// <summary>The negotiation block was missing or malformed.</summary>
    public static CatalogInvalidRequestField Contract { get; } = new("contract");

    /// <summary>The plan source was missing or malformed.</summary>
    public static CatalogInvalidRequestField Source { get; } = new("source");

    /// <summary>The supplied card was missing its media type, URL, or data.</summary>
    public static CatalogInvalidRequestField Card { get; } = new("card");

    /// <summary>The requested configuration scope is not one this runtime writes.</summary>
    public static CatalogInvalidRequestField Scope { get; } = new("scope");

    /// <summary>Returns a value indicating whether two <see cref="CatalogInvalidRequestField"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogInvalidRequestField left, CatalogInvalidRequestField right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogInvalidRequestField"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogInvalidRequestField left, CatalogInvalidRequestField right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogInvalidRequestField other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogInvalidRequestField other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogInvalidRequestField}"/> for serializing <see cref="CatalogInvalidRequestField"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogInvalidRequestField>
    {
        /// <inheritdoc />
        public override CatalogInvalidRequestField Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogInvalidRequestField value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogInvalidRequestField));
        }
    }
}


/// <summary>Why the catalog authority did not accept the caller's identity.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogAuthenticationRequiredReason : IEquatable<CatalogAuthenticationRequiredReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogAuthenticationRequiredReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogAuthenticationRequiredReason"/>.</param>
    [JsonConstructor]
    public CatalogAuthenticationRequiredReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogAuthenticationRequiredReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>No credential was presented, so there is nothing to refresh and the caller must sign in.</summary>
    public static CatalogAuthenticationRequiredReason NoCredential { get; } = new("no-credential");

    /// <summary>A credential was presented and its lifetime has elapsed. A silent refresh is worth attempting before prompting anyone.</summary>
    public static CatalogAuthenticationRequiredReason CredentialExpired { get; } = new("credential-expired");

    /// <summary>A credential was presented and the authority refused it, for example because it was revoked, malformed, or issued for another audience. Refreshing the same rejected credential is not useful; the caller must sign in again.</summary>
    public static CatalogAuthenticationRequiredReason CredentialRejected { get; } = new("credential-rejected");

    /// <summary>Returns a value indicating whether two <see cref="CatalogAuthenticationRequiredReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogAuthenticationRequiredReason left, CatalogAuthenticationRequiredReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogAuthenticationRequiredReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogAuthenticationRequiredReason left, CatalogAuthenticationRequiredReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogAuthenticationRequiredReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogAuthenticationRequiredReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogAuthenticationRequiredReason}"/> for serializing <see cref="CatalogAuthenticationRequiredReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogAuthenticationRequiredReason>
    {
        /// <inheritdoc />
        public override CatalogAuthenticationRequiredReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogAuthenticationRequiredReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogAuthenticationRequiredReason));
        }
    }
}


/// <summary>Categorised network failure, low cardinality so it can be aggregated without carrying a URL.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogNetworkFailureReason : IEquatable<CatalogNetworkFailureReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogNetworkFailureReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogNetworkFailureReason"/>.</param>
    [JsonConstructor]
    public CatalogNetworkFailureReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogNetworkFailureReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>No network is available, so nothing was attempted.</summary>
    public static CatalogNetworkFailureReason Offline { get; } = new("offline");

    /// <summary>The authority's name could not be resolved.</summary>
    public static CatalogNetworkFailureReason Dns { get; } = new("dns");

    /// <summary>The request exceeded its time budget.</summary>
    public static CatalogNetworkFailureReason Timeout { get; } = new("timeout");

    /// <summary>The TLS handshake or certificate validation failed.</summary>
    public static CatalogNetworkFailureReason Tls { get; } = new("tls");

    /// <summary>The connection was refused or reset.</summary>
    public static CatalogNetworkFailureReason ConnectionRefused { get; } = new("connection-refused");

    /// <summary>The configured proxy returned 407 and requires authentication.</summary>
    public static CatalogNetworkFailureReason ProxyAuthenticationRequired { get; } = new("proxy-authentication-required");

    /// <summary>The authority rate-limited requests and supplied or implied a bounded cooldown.</summary>
    public static CatalogNetworkFailureReason RateLimited { get; } = new("rate-limited");

    /// <summary>The authority returned a transient 5xx response.</summary>
    public static CatalogNetworkFailureReason ServiceUnavailable { get; } = new("service-unavailable");

    /// <summary>The authority returned another status the runtime treats as a failure.</summary>
    public static CatalogNetworkFailureReason HttpStatus { get; } = new("http-status");

    /// <summary>The response exceeded the permitted size.</summary>
    public static CatalogNetworkFailureReason ResponseTooLarge { get; } = new("response-too-large");

    /// <summary>A redirect was refused by the runtime's redirect policy.</summary>
    public static CatalogNetworkFailureReason RedirectRejected { get; } = new("redirect-rejected");

    /// <summary>Returns a value indicating whether two <see cref="CatalogNetworkFailureReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogNetworkFailureReason left, CatalogNetworkFailureReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogNetworkFailureReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogNetworkFailureReason left, CatalogNetworkFailureReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogNetworkFailureReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogNetworkFailureReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogNetworkFailureReason}"/> for serializing <see cref="CatalogNetworkFailureReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogNetworkFailureReason>
    {
        /// <inheritdoc />
        public override CatalogNetworkFailureReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogNetworkFailureReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogNetworkFailureReason));
        }
    }
}


/// <summary>Which hardened-fetch control refused a retrieval.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogUnsafeRetrievalReason : IEquatable<CatalogUnsafeRetrievalReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogUnsafeRetrievalReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogUnsafeRetrievalReason"/>.</param>
    [JsonConstructor]
    public CatalogUnsafeRetrievalReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogUnsafeRetrievalReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The URL used a scheme the runtime refuses to fetch.</summary>
    public static CatalogUnsafeRetrievalReason BlockedScheme { get; } = new("blocked-scheme");

    /// <summary>The URL embedded credentials.</summary>
    public static CatalogUnsafeRetrievalReason CredentialsInUrl { get; } = new("credentials-in-url");

    /// <summary>The URL resolved to a loopback, private, link-local, or cloud metadata address.</summary>
    public static CatalogUnsafeRetrievalReason BlockedAddress { get; } = new("blocked-address");

    /// <summary>A redirect target resolved to a blocked address.</summary>
    public static CatalogUnsafeRetrievalReason RedirectToBlockedAddress { get; } = new("redirect-to-blocked-address");

    /// <summary>The configured proxy policy refused the request.</summary>
    public static CatalogUnsafeRetrievalReason ProxyRejected { get; } = new("proxy-rejected");

    /// <summary>The authority is not permitted for card retrieval.</summary>
    public static CatalogUnsafeRetrievalReason HostNotPermitted { get; } = new("host-not-permitted");

    /// <summary>Returns a value indicating whether two <see cref="CatalogUnsafeRetrievalReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogUnsafeRetrievalReason left, CatalogUnsafeRetrievalReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogUnsafeRetrievalReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogUnsafeRetrievalReason left, CatalogUnsafeRetrievalReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogUnsafeRetrievalReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogUnsafeRetrievalReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogUnsafeRetrievalReason}"/> for serializing <see cref="CatalogUnsafeRetrievalReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogUnsafeRetrievalReason>
    {
        /// <inheritdoc />
        public override CatalogUnsafeRetrievalReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogUnsafeRetrievalReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogUnsafeRetrievalReason));
        }
    }
}


/// <summary>Media type a catalog card is interpreted as.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogMediaType : IEquatable<CatalogMediaType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogMediaType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogMediaType"/>.</param>
    [JsonConstructor]
    public CatalogMediaType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogMediaType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The current MCP server card media type.</summary>
    public static CatalogMediaType ApplicationMcpServerCardJson { get; } = new("application/mcp-server-card+json");

    /// <summary>The legacy MCP server card media type, accepted for compatibility.</summary>
    public static CatalogMediaType ApplicationMcpServerJson { get; } = new("application/mcp-server+json");

    /// <summary>An AI skill card. Representable and searchable, but typed non-installable.</summary>
    public static CatalogMediaType ApplicationAiSkill { get; } = new("application/ai-skill");

    /// <summary>Returns a value indicating whether two <see cref="CatalogMediaType"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogMediaType left, CatalogMediaType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogMediaType"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogMediaType left, CatalogMediaType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogMediaType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogMediaType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogMediaType}"/> for serializing <see cref="CatalogMediaType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogMediaType>
    {
        /// <inheritdoc />
        public override CatalogMediaType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogMediaType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogMediaType));
        }
    }
}


/// <summary>How a card failed validation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogMalformedCardReason : IEquatable<CatalogMalformedCardReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogMalformedCardReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogMalformedCardReason"/>.</param>
    [JsonConstructor]
    public CatalogMalformedCardReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogMalformedCardReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The document is not well-formed JSON.</summary>
    public static CatalogMalformedCardReason InvalidJson { get; } = new("invalid-json");

    /// <summary>The document does not satisfy its media type's schema.</summary>
    public static CatalogMalformedCardReason SchemaViolation { get; } = new("schema-violation");

    /// <summary>The declared media type is not one this runtime understands.</summary>
    public static CatalogMalformedCardReason UnsupportedMediaType { get; } = new("unsupported-media-type");

    /// <summary>A field the media type requires is absent.</summary>
    public static CatalogMalformedCardReason MissingRequiredField { get; } = new("missing-required-field");

    /// <summary>The document exceeded the permitted size.</summary>
    public static CatalogMalformedCardReason SizeLimitExceeded { get; } = new("size-limit-exceeded");

    /// <summary>Returns a value indicating whether two <see cref="CatalogMalformedCardReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogMalformedCardReason left, CatalogMalformedCardReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogMalformedCardReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogMalformedCardReason left, CatalogMalformedCardReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogMalformedCardReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogMalformedCardReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogMalformedCardReason}"/> for serializing <see cref="CatalogMalformedCardReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogMalformedCardReason>
    {
        /// <inheritdoc />
        public override CatalogMalformedCardReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogMalformedCardReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogMalformedCardReason));
        }
    }
}


/// <summary>Which wire-contract rule an upstream response broke.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogContractViolationReason : IEquatable<CatalogContractViolationReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogContractViolationReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogContractViolationReason"/>.</param>
    [JsonConstructor]
    public CatalogContractViolationReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogContractViolationReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A result carried both a URL and embedded data, when exactly one is permitted.</summary>
    public static CatalogContractViolationReason BothUrlAndData { get; } = new("both-url-and-data");

    /// <summary>A result carried neither a URL nor embedded data, when exactly one is required.</summary>
    public static CatalogContractViolationReason NeitherUrlNorData { get; } = new("neither-url-nor-data");

    /// <summary>Two results claimed the same normalised identity.</summary>
    public static CatalogContractViolationReason DuplicateIdentity { get; } = new("duplicate-identity");

    /// <summary>A result declared no media type, or one this contract does not model.</summary>
    public static CatalogContractViolationReason UnknownMediaType { get; } = new("unknown-media-type");

    /// <summary>Returns a value indicating whether two <see cref="CatalogContractViolationReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogContractViolationReason left, CatalogContractViolationReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogContractViolationReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogContractViolationReason left, CatalogContractViolationReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogContractViolationReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogContractViolationReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogContractViolationReason}"/> for serializing <see cref="CatalogContractViolationReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogContractViolationReason>
    {
        /// <inheritdoc />
        public override CatalogContractViolationReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogContractViolationReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogContractViolationReason));
        }
    }
}


/// <summary>Why no usable transport could be offered.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogUnavailableTransportReason : IEquatable<CatalogUnavailableTransportReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogUnavailableTransportReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogUnavailableTransportReason"/>.</param>
    [JsonConstructor]
    public CatalogUnavailableTransportReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogUnavailableTransportReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The card advertises no transport this runtime can use.</summary>
    public static CatalogUnavailableTransportReason NoEligibleTransport { get; } = new("no-eligible-transport");

    /// <summary>Every advertised transport is of a kind this runtime does not implement.</summary>
    public static CatalogUnavailableTransportReason TransportNotSupported { get; } = new("transport-not-supported");

    /// <summary>Eligible remotes could not be enumerated, so no explicit choice can be offered.</summary>
    public static CatalogUnavailableTransportReason RemoteEnumerationUnavailable { get; } = new("remote-enumeration-unavailable");

    /// <summary>Returns a value indicating whether two <see cref="CatalogUnavailableTransportReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogUnavailableTransportReason left, CatalogUnavailableTransportReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogUnavailableTransportReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogUnavailableTransportReason left, CatalogUnavailableTransportReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogUnavailableTransportReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogUnavailableTransportReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogUnavailableTransportReason}"/> for serializing <see cref="CatalogUnavailableTransportReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogUnavailableTransportReason>
    {
        /// <inheritdoc />
        public override CatalogUnavailableTransportReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogUnavailableTransportReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogUnavailableTransportReason));
        }
    }
}


/// <summary>Why a discoverable candidate cannot be installed.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogNotInstallableReason : IEquatable<CatalogNotInstallableReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogNotInstallableReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogNotInstallableReason"/>.</param>
    [JsonConstructor]
    public CatalogNotInstallableReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogNotInstallableReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>This kind of resource is not installable through this surface.</summary>
    public static CatalogNotInstallableReason KindNotInstallable { get; } = new("kind-not-installable");

    /// <summary>AI skills are discoverable but have no typed importer in this phase.</summary>
    public static CatalogNotInstallableReason AiSkillNotInstallable { get; } = new("ai-skill-not-installable");

    /// <summary>Policy forbids installing this candidate.</summary>
    public static CatalogNotInstallableReason PolicyForbids { get; } = new("policy-forbids");

    /// <summary>Returns a value indicating whether two <see cref="CatalogNotInstallableReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogNotInstallableReason left, CatalogNotInstallableReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogNotInstallableReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogNotInstallableReason left, CatalogNotInstallableReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogNotInstallableReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogNotInstallableReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogNotInstallableReason}"/> for serializing <see cref="CatalogNotInstallableReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogNotInstallableReason>
    {
        /// <inheritdoc />
        public override CatalogNotInstallableReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogNotInstallableReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogNotInstallableReason));
        }
    }
}


/// <summary>Why a catalog operation is not available on this runtime.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogUnavailableReason : IEquatable<CatalogUnavailableReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogUnavailableReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogUnavailableReason"/>.</param>
    [JsonConstructor]
    public CatalogUnavailableReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogUnavailableReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Bounded search is not wired up on this runtime build.</summary>
    public static CatalogUnavailableReason SearchUnavailable { get; } = new("search-unavailable");

    /// <summary>Install planning is not wired up on this runtime build.</summary>
    public static CatalogUnavailableReason PlanningUnavailable { get; } = new("planning-unavailable");

    /// <summary>No catalog authority is configured for this runtime.</summary>
    public static CatalogUnavailableReason AuthorityNotConfigured { get; } = new("authority-not-configured");

    /// <summary>The surface is disabled by policy on this runtime.</summary>
    public static CatalogUnavailableReason DisabledByPolicy { get; } = new("disabled-by-policy");

    /// <summary>Returns a value indicating whether two <see cref="CatalogUnavailableReason"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogUnavailableReason left, CatalogUnavailableReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogUnavailableReason"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogUnavailableReason left, CatalogUnavailableReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogUnavailableReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogUnavailableReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogUnavailableReason}"/> for serializing <see cref="CatalogUnavailableReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogUnavailableReason>
    {
        /// <inheritdoc />
        public override CatalogUnavailableReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogUnavailableReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogUnavailableReason));
        }
    }
}


/// <summary>Persisted extension discovery source.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct DiscoveredExtensionSource : IEquatable<DiscoveredExtensionSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="DiscoveredExtensionSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="DiscoveredExtensionSource"/>.</param>
    [JsonConstructor]
    public DiscoveredExtensionSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="DiscoveredExtensionSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Extension discovered from the user's extensions directory.</summary>
    public static DiscoveredExtensionSource User { get; } = new("user");

    /// <summary>Extension contributed by an installed plugin.</summary>
    public static DiscoveredExtensionSource Plugin { get; } = new("plugin");

    /// <summary>Returns a value indicating whether two <see cref="DiscoveredExtensionSource"/> instances are equivalent.</summary>
    public static bool operator ==(DiscoveredExtensionSource left, DiscoveredExtensionSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="DiscoveredExtensionSource"/> instances are not equivalent.</summary>
    public static bool operator !=(DiscoveredExtensionSource left, DiscoveredExtensionSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is DiscoveredExtensionSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(DiscoveredExtensionSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{DiscoveredExtensionSource}"/> for serializing <see cref="DiscoveredExtensionSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<DiscoveredExtensionSource>
    {
        /// <inheritdoc />
        public override DiscoveredExtensionSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, DiscoveredExtensionSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(DiscoveredExtensionSource));
        }
    }
}


/// <summary>Effective extension loading and agent-management mode.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct DiscoveredExtensionMode : IEquatable<DiscoveredExtensionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="DiscoveredExtensionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="DiscoveredExtensionMode"/>.</param>
    [JsonConstructor]
    public DiscoveredExtensionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="DiscoveredExtensionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Extensions are not loaded.</summary>
    public static DiscoveredExtensionMode Disabled { get; } = new("disabled");

    /// <summary>Extensions are loaded, but the agent cannot create, reload, or manage them.</summary>
    public static DiscoveredExtensionMode LoadOnly { get; } = new("load_only");

    /// <summary>Extensions are loaded and the agent can create, reload, and manage them.</summary>
    public static DiscoveredExtensionMode LoadAndAugment { get; } = new("load_and_augment");

    /// <summary>Returns a value indicating whether two <see cref="DiscoveredExtensionMode"/> instances are equivalent.</summary>
    public static bool operator ==(DiscoveredExtensionMode left, DiscoveredExtensionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="DiscoveredExtensionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(DiscoveredExtensionMode left, DiscoveredExtensionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is DiscoveredExtensionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(DiscoveredExtensionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{DiscoveredExtensionMode}"/> for serializing <see cref="DiscoveredExtensionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<DiscoveredExtensionMode>
    {
        /// <inheritdoc />
        public override DiscoveredExtensionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, DiscoveredExtensionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(DiscoveredExtensionMode));
        }
    }
}


/// <summary>Whether an MCP server candidate can be planned for installation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogMcpServerInstallability : IEquatable<CatalogMcpServerInstallability>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogMcpServerInstallability"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogMcpServerInstallability"/>.</param>
    [JsonConstructor]
    public CatalogMcpServerInstallability(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogMcpServerInstallability"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>An install plan can be computed for this MCP server candidate.</summary>
    public static CatalogMcpServerInstallability Installable { get; } = new("installable");

    /// <summary>Policy forbids installing this MCP server candidate.</summary>
    public static CatalogMcpServerInstallability NotInstallablePolicy { get; } = new("not-installable-policy");

    /// <summary>Returns a value indicating whether two <see cref="CatalogMcpServerInstallability"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogMcpServerInstallability left, CatalogMcpServerInstallability right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogMcpServerInstallability"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogMcpServerInstallability left, CatalogMcpServerInstallability right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogMcpServerInstallability other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogMcpServerInstallability other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogMcpServerInstallability}"/> for serializing <see cref="CatalogMcpServerInstallability"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogMcpServerInstallability>
    {
        /// <inheritdoc />
        public override CatalogMcpServerInstallability Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogMcpServerInstallability value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogMcpServerInstallability));
        }
    }
}


/// <summary>What kind of resource a catalog candidate describes.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CatalogCandidateKind : IEquatable<CatalogCandidateKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CatalogCandidateKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CatalogCandidateKind"/>.</param>
    [JsonConstructor]
    public CatalogCandidateKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CatalogCandidateKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>An MCP server, which can be planned for installation.</summary>
    public static CatalogCandidateKind McpServer { get; } = new("mcp-server");

    /// <summary>An AI skill, which is discoverable but not installable through this surface.</summary>
    public static CatalogCandidateKind AiSkill { get; } = new("ai-skill");

    /// <summary>Returns a value indicating whether two <see cref="CatalogCandidateKind"/> instances are equivalent.</summary>
    public static bool operator ==(CatalogCandidateKind left, CatalogCandidateKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CatalogCandidateKind"/> instances are not equivalent.</summary>
    public static bool operator !=(CatalogCandidateKind left, CatalogCandidateKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CatalogCandidateKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CatalogCandidateKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CatalogCandidateKind}"/> for serializing <see cref="CatalogCandidateKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CatalogCandidateKind>
    {
        /// <inheritdoc />
        public override CatalogCandidateKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CatalogCandidateKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CatalogCandidateKind));
        }
    }
}


/// <summary>Where completed plugin content was staged before atomic promotion.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PluginInstallStagingMode : IEquatable<PluginInstallStagingMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PluginInstallStagingMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PluginInstallStagingMode"/>.</param>
    [JsonConstructor]
    public PluginInstallStagingMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PluginInstallStagingMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A sibling of the installed-plugins root, outside the recursively watched tree.</summary>
    public static PluginInstallStagingMode External { get; } = new("external");

    /// <summary>A sibling of the destination plugin directory, used when external staging is unavailable.</summary>
    public static PluginInstallStagingMode DestinationSibling { get; } = new("destination_sibling");

    /// <summary>Returns a value indicating whether two <see cref="PluginInstallStagingMode"/> instances are equivalent.</summary>
    public static bool operator ==(PluginInstallStagingMode left, PluginInstallStagingMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PluginInstallStagingMode"/> instances are not equivalent.</summary>
    public static bool operator !=(PluginInstallStagingMode left, PluginInstallStagingMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PluginInstallStagingMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PluginInstallStagingMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PluginInstallStagingMode}"/> for serializing <see cref="PluginInstallStagingMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PluginInstallStagingMode>
    {
        /// <inheritdoc />
        public override PluginInstallStagingMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PluginInstallStagingMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PluginInstallStagingMode));
        }
    }
}


/// <summary>Which tier this directory belongs to.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SkillDiscoveryScope : IEquatable<SkillDiscoveryScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SkillDiscoveryScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SkillDiscoveryScope"/>.</param>
    [JsonConstructor]
    public SkillDiscoveryScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SkillDiscoveryScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A project's repository skill directory.</summary>
    public static SkillDiscoveryScope Project { get; } = new("project");

    /// <summary>The user's personal Copilot skill directory.</summary>
    public static SkillDiscoveryScope PersonalCopilot { get; } = new("personal-copilot");

    /// <summary>The user's personal agents skill directory.</summary>
    public static SkillDiscoveryScope PersonalAgents { get; } = new("personal-agents");

    /// <summary>A configured custom skill directory.</summary>
    public static SkillDiscoveryScope Custom { get; } = new("custom");

    /// <summary>Returns a value indicating whether two <see cref="SkillDiscoveryScope"/> instances are equivalent.</summary>
    public static bool operator ==(SkillDiscoveryScope left, SkillDiscoveryScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SkillDiscoveryScope"/> instances are not equivalent.</summary>
    public static bool operator !=(SkillDiscoveryScope left, SkillDiscoveryScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SkillDiscoveryScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SkillDiscoveryScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SkillDiscoveryScope}"/> for serializing <see cref="SkillDiscoveryScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SkillDiscoveryScope>
    {
        /// <inheritdoc />
        public override SkillDiscoveryScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SkillDiscoveryScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SkillDiscoveryScope));
        }
    }
}


/// <summary>Where the agent definition was loaded from.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentInfoSource : IEquatable<AgentInfoSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentInfoSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentInfoSource"/>.</param>
    [JsonConstructor]
    public AgentInfoSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentInfoSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Agent loaded from the user's personal agent configuration.</summary>
    public static AgentInfoSource User { get; } = new("user");

    /// <summary>Agent loaded from the current project's repository configuration.</summary>
    public static AgentInfoSource Project { get; } = new("project");

    /// <summary>Agent inherited from a parent project or workspace.</summary>
    public static AgentInfoSource Inherited { get; } = new("inherited");

    /// <summary>Agent provided by a remote runtime or service.</summary>
    public static AgentInfoSource Remote { get; } = new("remote");

    /// <summary>Agent contributed by an installed plugin.</summary>
    public static AgentInfoSource Plugin { get; } = new("plugin");

    /// <summary>Agent built into the Copilot runtime.</summary>
    public static AgentInfoSource Builtin { get; } = new("builtin");

    /// <summary>Returns a value indicating whether two <see cref="AgentInfoSource"/> instances are equivalent.</summary>
    public static bool operator ==(AgentInfoSource left, AgentInfoSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentInfoSource"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentInfoSource left, AgentInfoSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentInfoSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentInfoSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentInfoSource}"/> for serializing <see cref="AgentInfoSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentInfoSource>
    {
        /// <inheritdoc />
        public override AgentInfoSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentInfoSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentInfoSource));
        }
    }
}


/// <summary>Which tier this directory belongs to.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentDiscoveryPathScope : IEquatable<AgentDiscoveryPathScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentDiscoveryPathScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentDiscoveryPathScope"/>.</param>
    [JsonConstructor]
    public AgentDiscoveryPathScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentDiscoveryPathScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The user's personal agent configuration directory.</summary>
    public static AgentDiscoveryPathScope User { get; } = new("user");

    /// <summary>A project's repository agent directory.</summary>
    public static AgentDiscoveryPathScope Project { get; } = new("project");

    /// <summary>Returns a value indicating whether two <see cref="AgentDiscoveryPathScope"/> instances are equivalent.</summary>
    public static bool operator ==(AgentDiscoveryPathScope left, AgentDiscoveryPathScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentDiscoveryPathScope"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentDiscoveryPathScope left, AgentDiscoveryPathScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentDiscoveryPathScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentDiscoveryPathScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentDiscoveryPathScope}"/> for serializing <see cref="AgentDiscoveryPathScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentDiscoveryPathScope>
    {
        /// <inheritdoc />
        public override AgentDiscoveryPathScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentDiscoveryPathScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentDiscoveryPathScope));
        }
    }
}


/// <summary>Where this source lives — used for UI grouping.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct InstructionSourceLocation : IEquatable<InstructionSourceLocation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="InstructionSourceLocation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="InstructionSourceLocation"/>.</param>
    [JsonConstructor]
    public InstructionSourceLocation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="InstructionSourceLocation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Instructions live in user-level configuration.</summary>
    public static InstructionSourceLocation User { get; } = new("user");

    /// <summary>Instructions live in repository-level configuration.</summary>
    public static InstructionSourceLocation Repository { get; } = new("repository");

    /// <summary>Instructions live under the current working directory.</summary>
    public static InstructionSourceLocation WorkingDirectory { get; } = new("working-directory");

    /// <summary>Instructions live in plugin-provided configuration.</summary>
    public static InstructionSourceLocation Plugin { get; } = new("plugin");

    /// <summary>Returns a value indicating whether two <see cref="InstructionSourceLocation"/> instances are equivalent.</summary>
    public static bool operator ==(InstructionSourceLocation left, InstructionSourceLocation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="InstructionSourceLocation"/> instances are not equivalent.</summary>
    public static bool operator !=(InstructionSourceLocation left, InstructionSourceLocation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is InstructionSourceLocation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(InstructionSourceLocation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{InstructionSourceLocation}"/> for serializing <see cref="InstructionSourceLocation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<InstructionSourceLocation>
    {
        /// <inheritdoc />
        public override InstructionSourceLocation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, InstructionSourceLocation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(InstructionSourceLocation));
        }
    }
}


/// <summary>Category of instruction source — used for merge logic.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct InstructionSourceType : IEquatable<InstructionSourceType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="InstructionSourceType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="InstructionSourceType"/>.</param>
    [JsonConstructor]
    public InstructionSourceType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="InstructionSourceType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Instructions loaded from the user's home configuration.</summary>
    public static InstructionSourceType Home { get; } = new("home");

    /// <summary>Instructions loaded from repository-scoped files.</summary>
    public static InstructionSourceType Repo { get; } = new("repo");

    /// <summary>Instructions loaded from model-specific files.</summary>
    public static InstructionSourceType Model { get; } = new("model");

    /// <summary>Instructions loaded from VS Code instruction files.</summary>
    public static InstructionSourceType Vscode { get; } = new("vscode");

    /// <summary>Instructions discovered from nested agent files.</summary>
    public static InstructionSourceType NestedAgents { get; } = new("nested-agents");

    /// <summary>Instructions inherited from child instruction files.</summary>
    public static InstructionSourceType ChildInstructions { get; } = new("child-instructions");

    /// <summary>Instructions supplied by an installed plugin.</summary>
    public static InstructionSourceType Plugin { get; } = new("plugin");

    /// <summary>Returns a value indicating whether two <see cref="InstructionSourceType"/> instances are equivalent.</summary>
    public static bool operator ==(InstructionSourceType left, InstructionSourceType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="InstructionSourceType"/> instances are not equivalent.</summary>
    public static bool operator !=(InstructionSourceType left, InstructionSourceType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is InstructionSourceType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(InstructionSourceType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{InstructionSourceType}"/> for serializing <see cref="InstructionSourceType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<InstructionSourceType>
    {
        /// <inheritdoc />
        public override InstructionSourceType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, InstructionSourceType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(InstructionSourceType));
        }
    }
}


/// <summary>Whether the target is a single file or a directory of instruction files.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct InstructionDiscoveryPathKind : IEquatable<InstructionDiscoveryPathKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="InstructionDiscoveryPathKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="InstructionDiscoveryPathKind"/>.</param>
    [JsonConstructor]
    public InstructionDiscoveryPathKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="InstructionDiscoveryPathKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The target is a single instruction file.</summary>
    public static InstructionDiscoveryPathKind File { get; } = new("file");

    /// <summary>The target is a directory that holds instruction files.</summary>
    public static InstructionDiscoveryPathKind Directory { get; } = new("directory");

    /// <summary>Returns a value indicating whether two <see cref="InstructionDiscoveryPathKind"/> instances are equivalent.</summary>
    public static bool operator ==(InstructionDiscoveryPathKind left, InstructionDiscoveryPathKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="InstructionDiscoveryPathKind"/> instances are not equivalent.</summary>
    public static bool operator !=(InstructionDiscoveryPathKind left, InstructionDiscoveryPathKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is InstructionDiscoveryPathKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(InstructionDiscoveryPathKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{InstructionDiscoveryPathKind}"/> for serializing <see cref="InstructionDiscoveryPathKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<InstructionDiscoveryPathKind>
    {
        /// <inheritdoc />
        public override InstructionDiscoveryPathKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, InstructionDiscoveryPathKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(InstructionDiscoveryPathKind));
        }
    }
}


/// <summary>Which tier this target belongs to.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct InstructionDiscoveryPathLocation : IEquatable<InstructionDiscoveryPathLocation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="InstructionDiscoveryPathLocation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="InstructionDiscoveryPathLocation"/>.</param>
    [JsonConstructor]
    public InstructionDiscoveryPathLocation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="InstructionDiscoveryPathLocation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Instructions live in user-level configuration.</summary>
    public static InstructionDiscoveryPathLocation User { get; } = new("user");

    /// <summary>Instructions live in repository-level configuration.</summary>
    public static InstructionDiscoveryPathLocation Repository { get; } = new("repository");

    /// <summary>Instructions live under the current working directory.</summary>
    public static InstructionDiscoveryPathLocation WorkingDirectory { get; } = new("working-directory");

    /// <summary>Instructions live in plugin-provided configuration.</summary>
    public static InstructionDiscoveryPathLocation Plugin { get; } = new("plugin");

    /// <summary>Returns a value indicating whether two <see cref="InstructionDiscoveryPathLocation"/> instances are equivalent.</summary>
    public static bool operator ==(InstructionDiscoveryPathLocation left, InstructionDiscoveryPathLocation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="InstructionDiscoveryPathLocation"/> instances are not equivalent.</summary>
    public static bool operator !=(InstructionDiscoveryPathLocation left, InstructionDiscoveryPathLocation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is InstructionDiscoveryPathLocation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(InstructionDiscoveryPathLocation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{InstructionDiscoveryPathLocation}"/> for serializing <see cref="InstructionDiscoveryPathLocation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<InstructionDiscoveryPathLocation>
    {
        /// <inheritdoc />
        public override InstructionDiscoveryPathLocation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, InstructionDiscoveryPathLocation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(InstructionDiscoveryPathLocation));
        }
    }
}


/// <summary>Optional completion hint for the input (e.g. 'directory' for filesystem path completion).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SlashCommandInputCompletion : IEquatable<SlashCommandInputCompletion>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SlashCommandInputCompletion"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SlashCommandInputCompletion"/>.</param>
    [JsonConstructor]
    public SlashCommandInputCompletion(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SlashCommandInputCompletion"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Input should complete filesystem directories.</summary>
    public static SlashCommandInputCompletion Directory { get; } = new("directory");

    /// <summary>Returns a value indicating whether two <see cref="SlashCommandInputCompletion"/> instances are equivalent.</summary>
    public static bool operator ==(SlashCommandInputCompletion left, SlashCommandInputCompletion right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SlashCommandInputCompletion"/> instances are not equivalent.</summary>
    public static bool operator !=(SlashCommandInputCompletion left, SlashCommandInputCompletion right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SlashCommandInputCompletion other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SlashCommandInputCompletion other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SlashCommandInputCompletion}"/> for serializing <see cref="SlashCommandInputCompletion"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SlashCommandInputCompletion>
    {
        /// <inheritdoc />
        public override SlashCommandInputCompletion Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SlashCommandInputCompletion value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SlashCommandInputCompletion));
        }
    }
}


/// <summary>Coarse command category for grouping and behavior: runtime built-in, skill-backed command, or SDK/client-owned command.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SlashCommandKind : IEquatable<SlashCommandKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SlashCommandKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SlashCommandKind"/>.</param>
    [JsonConstructor]
    public SlashCommandKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SlashCommandKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Command implemented by the runtime.</summary>
    public static SlashCommandKind Builtin { get; } = new("builtin");

    /// <summary>Command backed by a skill.</summary>
    public static SlashCommandKind Skill { get; } = new("skill");

    /// <summary>Command registered by an SDK client or extension.</summary>
    public static SlashCommandKind Client { get; } = new("client");

    /// <summary>Returns a value indicating whether two <see cref="SlashCommandKind"/> instances are equivalent.</summary>
    public static bool operator ==(SlashCommandKind left, SlashCommandKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SlashCommandKind"/> instances are not equivalent.</summary>
    public static bool operator !=(SlashCommandKind left, SlashCommandKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SlashCommandKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SlashCommandKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SlashCommandKind}"/> for serializing <see cref="SlashCommandKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SlashCommandKind>
    {
        /// <inheritdoc />
        public override SlashCommandKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SlashCommandKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SlashCommandKind));
        }
    }
}


/// <summary>Path conventions used by this filesystem.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionFsSetProviderConventions : IEquatable<SessionFsSetProviderConventions>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionFsSetProviderConventions"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionFsSetProviderConventions"/>.</param>
    [JsonConstructor]
    public SessionFsSetProviderConventions(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionFsSetProviderConventions"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Paths use Windows path conventions.</summary>
    public static SessionFsSetProviderConventions Windows { get; } = new("windows");

    /// <summary>Paths use POSIX path conventions.</summary>
    public static SessionFsSetProviderConventions Posix { get; } = new("posix");

    /// <summary>Returns a value indicating whether two <see cref="SessionFsSetProviderConventions"/> instances are equivalent.</summary>
    public static bool operator ==(SessionFsSetProviderConventions left, SessionFsSetProviderConventions right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionFsSetProviderConventions"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionFsSetProviderConventions left, SessionFsSetProviderConventions right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionFsSetProviderConventions other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionFsSetProviderConventions other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionFsSetProviderConventions}"/> for serializing <see cref="SessionFsSetProviderConventions"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionFsSetProviderConventions>
    {
        /// <inheritdoc />
        public override SessionFsSetProviderConventions Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionFsSetProviderConventions value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionFsSetProviderConventions));
        }
    }
}


/// <summary>Repository host type.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionContextHostType : IEquatable<SessionContextHostType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionContextHostType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionContextHostType"/>.</param>
    [JsonConstructor]
    public SessionContextHostType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionContextHostType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Session repository is hosted on GitHub.</summary>
    public static SessionContextHostType GitHub { get; } = new("github");

    /// <summary>Session repository is hosted on Azure DevOps.</summary>
    public static SessionContextHostType Ado { get; } = new("ado");

    /// <summary>Returns a value indicating whether two <see cref="SessionContextHostType"/> instances are equivalent.</summary>
    public static bool operator ==(SessionContextHostType left, SessionContextHostType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionContextHostType"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionContextHostType left, SessionContextHostType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionContextHostType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionContextHostType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionContextHostType}"/> for serializing <see cref="SessionContextHostType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionContextHostType>
    {
        /// <inheritdoc />
        public override SessionContextHostType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionContextHostType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionContextHostType));
        }
    }
}


/// <summary>What a remote host says one of its sessions is doing right now. Deliberately coarse: this is what a host can report for EVERY session in a catalogue listing, without a client subscribing to each one. AHP's `SessionSummary.status` is the source today; `input-needed` covers both a permission prompt and an `ask_user` question, since the summary does not say which.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct RemoteSessionHostStatus : IEquatable<RemoteSessionHostStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="RemoteSessionHostStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="RemoteSessionHostStatus"/>.</param>
    [JsonConstructor]
    public RemoteSessionHostStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="RemoteSessionHostStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>No turn is running.</summary>
    public static RemoteSessionHostStatus Idle { get; } = new("idle");

    /// <summary>A turn is running.</summary>
    public static RemoteSessionHostStatus Working { get; } = new("working");

    /// <summary>The session is blocked on the user: a permission prompt or an `ask_user` question.</summary>
    public static RemoteSessionHostStatus InputNeeded { get; } = new("input-needed");

    /// <summary>The session ended its last turn in an error.</summary>
    public static RemoteSessionHostStatus Error { get; } = new("error");

    /// <summary>Returns a value indicating whether two <see cref="RemoteSessionHostStatus"/> instances are equivalent.</summary>
    public static bool operator ==(RemoteSessionHostStatus left, RemoteSessionHostStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="RemoteSessionHostStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(RemoteSessionHostStatus left, RemoteSessionHostStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is RemoteSessionHostStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(RemoteSessionHostStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{RemoteSessionHostStatus}"/> for serializing <see cref="RemoteSessionHostStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<RemoteSessionHostStatus>
    {
        /// <inheritdoc />
        public override RemoteSessionHostStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, RemoteSessionHostStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(RemoteSessionHostStatus));
        }
    }
}


/// <summary>Whether the remote task originated from CCA or CLI `--remote`.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct RemoteSessionMetadataTaskType : IEquatable<RemoteSessionMetadataTaskType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="RemoteSessionMetadataTaskType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="RemoteSessionMetadataTaskType"/>.</param>
    [JsonConstructor]
    public RemoteSessionMetadataTaskType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="RemoteSessionMetadataTaskType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>GitHub Copilot coding agent task.</summary>
    public static RemoteSessionMetadataTaskType Cca { get; } = new("cca");

    /// <summary>CLI remote task.</summary>
    public static RemoteSessionMetadataTaskType Cli { get; } = new("cli");

    /// <summary>Returns a value indicating whether two <see cref="RemoteSessionMetadataTaskType"/> instances are equivalent.</summary>
    public static bool operator ==(RemoteSessionMetadataTaskType left, RemoteSessionMetadataTaskType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="RemoteSessionMetadataTaskType"/> instances are not equivalent.</summary>
    public static bool operator !=(RemoteSessionMetadataTaskType left, RemoteSessionMetadataTaskType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is RemoteSessionMetadataTaskType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(RemoteSessionMetadataTaskType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{RemoteSessionMetadataTaskType}"/> for serializing <see cref="RemoteSessionMetadataTaskType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<RemoteSessionMetadataTaskType>
    {
        /// <inheritdoc />
        public override RemoteSessionMetadataTaskType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, RemoteSessionMetadataTaskType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(RemoteSessionMetadataTaskType));
        }
    }
}


/// <summary>Step status.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionsOpenProgressStatus : IEquatable<SessionsOpenProgressStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionsOpenProgressStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionsOpenProgressStatus"/>.</param>
    [JsonConstructor]
    public SessionsOpenProgressStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionsOpenProgressStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The step has started and has not yet finished.</summary>
    public static SessionsOpenProgressStatus InProgress { get; } = new("in-progress");

    /// <summary>The step has completed successfully.</summary>
    public static SessionsOpenProgressStatus Complete { get; } = new("complete");

    /// <summary>Returns a value indicating whether two <see cref="SessionsOpenProgressStatus"/> instances are equivalent.</summary>
    public static bool operator ==(SessionsOpenProgressStatus left, SessionsOpenProgressStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionsOpenProgressStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionsOpenProgressStatus left, SessionsOpenProgressStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionsOpenProgressStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionsOpenProgressStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionsOpenProgressStatus}"/> for serializing <see cref="SessionsOpenProgressStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionsOpenProgressStatus>
    {
        /// <inheritdoc />
        public override SessionsOpenProgressStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionsOpenProgressStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionsOpenProgressStatus));
        }
    }
}


/// <summary>Handoff step.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionsOpenProgressStep : IEquatable<SessionsOpenProgressStep>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionsOpenProgressStep"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionsOpenProgressStep"/>.</param>
    [JsonConstructor]
    public SessionsOpenProgressStep(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionsOpenProgressStep"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Loading the source session's events from the remote service.</summary>
    public static SessionsOpenProgressStep LoadSession { get; } = new("load-session");

    /// <summary>Validating that the local repository matches the remote session's repository.</summary>
    public static SessionsOpenProgressStep ValidateRepo { get; } = new("validate-repo");

    /// <summary>Checking the local working tree for uncommitted changes that would block the handoff.</summary>
    public static SessionsOpenProgressStep CheckChanges { get; } = new("check-changes");

    /// <summary>Checking out the branch associated with the remote session in the local working tree.</summary>
    public static SessionsOpenProgressStep CheckoutBranch { get; } = new("checkout-branch");

    /// <summary>Creating the new local session and seeding it with the source session's events.</summary>
    public static SessionsOpenProgressStep CreateSession { get; } = new("create-session");

    /// <summary>Persisting the newly-created local session to disk.</summary>
    public static SessionsOpenProgressStep SaveSession { get; } = new("save-session");

    /// <summary>Returns a value indicating whether two <see cref="SessionsOpenProgressStep"/> instances are equivalent.</summary>
    public static bool operator ==(SessionsOpenProgressStep left, SessionsOpenProgressStep right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionsOpenProgressStep"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionsOpenProgressStep left, SessionsOpenProgressStep right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionsOpenProgressStep other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionsOpenProgressStep other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionsOpenProgressStep}"/> for serializing <see cref="SessionsOpenProgressStep"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionsOpenProgressStep>
    {
        /// <inheritdoc />
        public override SessionsOpenProgressStep Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionsOpenProgressStep value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionsOpenProgressStep));
        }
    }
}


/// <summary>Outcome of the open request.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionsOpenStatus : IEquatable<SessionsOpenStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionsOpenStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionsOpenStatus"/>.</param>
    [JsonConstructor]
    public SessionsOpenStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionsOpenStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A new session was created.</summary>
    public static SessionsOpenStatus Created { get; } = new("created");

    /// <summary>An existing session was loaded or reattached.</summary>
    public static SessionsOpenStatus Resumed { get; } = new("resumed");

    /// <summary>No matching persisted session was found.</summary>
    public static SessionsOpenStatus NotFound { get; } = new("not_found");

    /// <summary>Connected to an existing remote session.</summary>
    public static SessionsOpenStatus Connected { get; } = new("connected");

    /// <summary>Remote session was handed off to a new local session.</summary>
    public static SessionsOpenStatus HandedOff { get; } = new("handed_off");

    /// <summary>Returns a value indicating whether two <see cref="SessionsOpenStatus"/> instances are equivalent.</summary>
    public static bool operator ==(SessionsOpenStatus left, SessionsOpenStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionsOpenStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionsOpenStatus left, SessionsOpenStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionsOpenStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionsOpenStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionsOpenStatus}"/> for serializing <see cref="SessionsOpenStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionsOpenStatus>
    {
        /// <inheritdoc />
        public override SessionsOpenStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionsOpenStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionsOpenStatus));
        }
    }
}


/// <summary>Neutral SDK discriminator for the connected remote session kind.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ConnectedRemoteSessionMetadataKind : IEquatable<ConnectedRemoteSessionMetadataKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ConnectedRemoteSessionMetadataKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ConnectedRemoteSessionMetadataKind"/>.</param>
    [JsonConstructor]
    public ConnectedRemoteSessionMetadataKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ConnectedRemoteSessionMetadataKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Remote CLI session.</summary>
    public static ConnectedRemoteSessionMetadataKind RemoteSession { get; } = new("remote-session");

    /// <summary>GitHub Copilot coding agent session.</summary>
    public static ConnectedRemoteSessionMetadataKind CodingAgent { get; } = new("coding-agent");

    /// <summary>Returns a value indicating whether two <see cref="ConnectedRemoteSessionMetadataKind"/> instances are equivalent.</summary>
    public static bool operator ==(ConnectedRemoteSessionMetadataKind left, ConnectedRemoteSessionMetadataKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ConnectedRemoteSessionMetadataKind"/> instances are not equivalent.</summary>
    public static bool operator !=(ConnectedRemoteSessionMetadataKind left, ConnectedRemoteSessionMetadataKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ConnectedRemoteSessionMetadataKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ConnectedRemoteSessionMetadataKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ConnectedRemoteSessionMetadataKind}"/> for serializing <see cref="ConnectedRemoteSessionMetadataKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ConnectedRemoteSessionMetadataKind>
    {
        /// <inheritdoc />
        public override ConnectedRemoteSessionMetadataKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ConnectedRemoteSessionMetadataKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ConnectedRemoteSessionMetadataKind));
        }
    }
}


/// <summary>Which session sources to include. Defaults to `local` for backward compatibility.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionSource : IEquatable<SessionSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionSource"/>.</param>
    [JsonConstructor]
    public SessionSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Return only local sessions.</summary>
    public static SessionSource Local { get; } = new("local");

    /// <summary>Return only remote sessions.</summary>
    public static SessionSource Remote { get; } = new("remote");

    /// <summary>Return both local and remote sessions.</summary>
    public static SessionSource All { get; } = new("all");

    /// <summary>Returns a value indicating whether two <see cref="SessionSource"/> instances are equivalent.</summary>
    public static bool operator ==(SessionSource left, SessionSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionSource"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionSource left, SessionSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionSource}"/> for serializing <see cref="SessionSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionSource>
    {
        /// <inheritdoc />
        public override SessionSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionSource));
        }
    }
}


/// <summary>Cursor status: 'ok' means the cursor was applied successfully; 'expired' means the cursor referred to an event that no longer exists in history (e.g. truncated or compacted away) and the read fell back to a boundary of the remaining history (the beginning for a forward read, the tail for a backward read). The fallback page is a fresh boundary snapshot, not a continuation of the requested cursor, so it may overlap already-rendered events; on 'expired' a consumer should reset/rebase its pagination state (or deduplicate by event id) before continuing from the returned cursor.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct EventsCursorStatus : IEquatable<EventsCursorStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="EventsCursorStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="EventsCursorStatus"/>.</param>
    [JsonConstructor]
    public EventsCursorStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="EventsCursorStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The cursor was applied successfully.</summary>
    public static EventsCursorStatus Ok { get; } = new("ok");

    /// <summary>The cursor referred to history that is no longer available.</summary>
    public static EventsCursorStatus Expired { get; } = new("expired");

    /// <summary>Returns a value indicating whether two <see cref="EventsCursorStatus"/> instances are equivalent.</summary>
    public static bool operator ==(EventsCursorStatus left, EventsCursorStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="EventsCursorStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(EventsCursorStatus left, EventsCursorStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is EventsCursorStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(EventsCursorStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{EventsCursorStatus}"/> for serializing <see cref="EventsCursorStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<EventsCursorStatus>
    {
        /// <inheritdoc />
        public override EventsCursorStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, EventsCursorStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(EventsCursorStatus));
        }
    }
}


/// <summary>Direction to page through the session's persisted event history. 'forward' pages from the cursor toward newer events; 'backward' returns the newest window first (tail-first) and pages toward older events. Events within a returned batch are always chronological (oldest-to-newest), even for a backward read.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct EventsReadDirection : IEquatable<EventsReadDirection>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="EventsReadDirection"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="EventsReadDirection"/>.</param>
    [JsonConstructor]
    public EventsReadDirection(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="EventsReadDirection"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Page from the cursor toward newer events (default).</summary>
    public static EventsReadDirection Forward { get; } = new("forward");

    /// <summary>Tail-first: return the newest events and page toward older events.</summary>
    public static EventsReadDirection Backward { get; } = new("backward");

    /// <summary>Returns a value indicating whether two <see cref="EventsReadDirection"/> instances are equivalent.</summary>
    public static bool operator ==(EventsReadDirection left, EventsReadDirection right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="EventsReadDirection"/> instances are not equivalent.</summary>
    public static bool operator !=(EventsReadDirection left, EventsReadDirection right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is EventsReadDirection other && Equals(other);

    /// <inheritdoc />
    public bool Equals(EventsReadDirection other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{EventsReadDirection}"/> for serializing <see cref="EventsReadDirection"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<EventsReadDirection>
    {
        /// <inheritdoc />
        public override EventsReadDirection Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, EventsReadDirection value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(EventsReadDirection));
        }
    }
}


/// <summary>Kind of attention required when status === "attention". Meaningful only when status === "attention".</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistryLiveTargetEntryAttentionKind : IEquatable<AgentRegistryLiveTargetEntryAttentionKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistryLiveTargetEntryAttentionKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistryLiveTargetEntryAttentionKind"/>.</param>
    [JsonConstructor]
    public AgentRegistryLiveTargetEntryAttentionKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistryLiveTargetEntryAttentionKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Session is blocked on an unrecoverable error.</summary>
    public static AgentRegistryLiveTargetEntryAttentionKind Error { get; } = new("error");

    /// <summary>Session is waiting for a tool-permission decision.</summary>
    public static AgentRegistryLiveTargetEntryAttentionKind Permission { get; } = new("permission");

    /// <summary>Session is waiting for the user to approve or reject a plan.</summary>
    public static AgentRegistryLiveTargetEntryAttentionKind ExitPlan { get; } = new("exit_plan");

    /// <summary>Session is waiting on an elicitation prompt.</summary>
    public static AgentRegistryLiveTargetEntryAttentionKind Elicitation { get; } = new("elicitation");

    /// <summary>Session is waiting for free-form user input.</summary>
    public static AgentRegistryLiveTargetEntryAttentionKind UserInput { get; } = new("user_input");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryAttentionKind"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistryLiveTargetEntryAttentionKind left, AgentRegistryLiveTargetEntryAttentionKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryAttentionKind"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistryLiveTargetEntryAttentionKind left, AgentRegistryLiveTargetEntryAttentionKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistryLiveTargetEntryAttentionKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistryLiveTargetEntryAttentionKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistryLiveTargetEntryAttentionKind}"/> for serializing <see cref="AgentRegistryLiveTargetEntryAttentionKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistryLiveTargetEntryAttentionKind>
    {
        /// <inheritdoc />
        public override AgentRegistryLiveTargetEntryAttentionKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistryLiveTargetEntryAttentionKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistryLiveTargetEntryAttentionKind));
        }
    }
}


/// <summary>Process kind tag for the registry entry.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistryLiveTargetEntryKind : IEquatable<AgentRegistryLiveTargetEntryKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistryLiveTargetEntryKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistryLiveTargetEntryKind"/>.</param>
    [JsonConstructor]
    public AgentRegistryLiveTargetEntryKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistryLiveTargetEntryKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Interactive Copilot CLI exposing a UI server (legacy/normal CLI process).</summary>
    public static AgentRegistryLiveTargetEntryKind UiServer { get; } = new("ui-server");

    /// <summary>Headless `--server --managed-server` child spawned by a controller.</summary>
    public static AgentRegistryLiveTargetEntryKind ManagedServer { get; } = new("managed-server");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryKind"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistryLiveTargetEntryKind left, AgentRegistryLiveTargetEntryKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryKind"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistryLiveTargetEntryKind left, AgentRegistryLiveTargetEntryKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistryLiveTargetEntryKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistryLiveTargetEntryKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistryLiveTargetEntryKind}"/> for serializing <see cref="AgentRegistryLiveTargetEntryKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistryLiveTargetEntryKind>
    {
        /// <inheritdoc />
        public override AgentRegistryLiveTargetEntryKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistryLiveTargetEntryKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistryLiveTargetEntryKind));
        }
    }
}


/// <summary>How the most recent turn ended (clean vs aborted). Lets the renderer distinguish done from done_cancelled.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistryLiveTargetEntryLastTerminalEvent : IEquatable<AgentRegistryLiveTargetEntryLastTerminalEvent>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistryLiveTargetEntryLastTerminalEvent"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistryLiveTargetEntryLastTerminalEvent"/>.</param>
    [JsonConstructor]
    public AgentRegistryLiveTargetEntryLastTerminalEvent(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistryLiveTargetEntryLastTerminalEvent"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Last turn ended cleanly (model returned a final assistant message).</summary>
    public static AgentRegistryLiveTargetEntryLastTerminalEvent TurnEnd { get; } = new("turn_end");

    /// <summary>Last turn was aborted (e.g. user interrupted).</summary>
    public static AgentRegistryLiveTargetEntryLastTerminalEvent Abort { get; } = new("abort");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryLastTerminalEvent"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistryLiveTargetEntryLastTerminalEvent left, AgentRegistryLiveTargetEntryLastTerminalEvent right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryLastTerminalEvent"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistryLiveTargetEntryLastTerminalEvent left, AgentRegistryLiveTargetEntryLastTerminalEvent right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistryLiveTargetEntryLastTerminalEvent other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistryLiveTargetEntryLastTerminalEvent other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistryLiveTargetEntryLastTerminalEvent}"/> for serializing <see cref="AgentRegistryLiveTargetEntryLastTerminalEvent"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistryLiveTargetEntryLastTerminalEvent>
    {
        /// <inheritdoc />
        public override AgentRegistryLiveTargetEntryLastTerminalEvent Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistryLiveTargetEntryLastTerminalEvent value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistryLiveTargetEntryLastTerminalEvent));
        }
    }
}


/// <summary>Coarse lifecycle status of the foreground session.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistryLiveTargetEntryStatus : IEquatable<AgentRegistryLiveTargetEntryStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistryLiveTargetEntryStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistryLiveTargetEntryStatus"/>.</param>
    [JsonConstructor]
    public AgentRegistryLiveTargetEntryStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistryLiveTargetEntryStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Session is actively processing a turn.</summary>
    public static AgentRegistryLiveTargetEntryStatus Working { get; } = new("working");

    /// <summary>Session is idle, waiting for input.</summary>
    public static AgentRegistryLiveTargetEntryStatus Waiting { get; } = new("waiting");

    /// <summary>Last turn completed successfully.</summary>
    public static AgentRegistryLiveTargetEntryStatus Done { get; } = new("done");

    /// <summary>Session needs user attention (see attentionKind for the specific reason).</summary>
    public static AgentRegistryLiveTargetEntryStatus Attention { get; } = new("attention");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryStatus"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistryLiveTargetEntryStatus left, AgentRegistryLiveTargetEntryStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLiveTargetEntryStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistryLiveTargetEntryStatus left, AgentRegistryLiveTargetEntryStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistryLiveTargetEntryStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistryLiveTargetEntryStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistryLiveTargetEntryStatus}"/> for serializing <see cref="AgentRegistryLiveTargetEntryStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistryLiveTargetEntryStatus>
    {
        /// <inheritdoc />
        public override AgentRegistryLiveTargetEntryStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistryLiveTargetEntryStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistryLiveTargetEntryStatus));
        }
    }
}


/// <summary>Categorized reason for log-open failure.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistryLogCaptureOpenErrorReason : IEquatable<AgentRegistryLogCaptureOpenErrorReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistryLogCaptureOpenErrorReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistryLogCaptureOpenErrorReason"/>.</param>
    [JsonConstructor]
    public AgentRegistryLogCaptureOpenErrorReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistryLogCaptureOpenErrorReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Filesystem permission denied opening the log file.</summary>
    public static AgentRegistryLogCaptureOpenErrorReason Permission { get; } = new("permission");

    /// <summary>No space left on device.</summary>
    public static AgentRegistryLogCaptureOpenErrorReason DiskFull { get; } = new("disk_full");

    /// <summary>Other / uncategorized open failure.</summary>
    public static AgentRegistryLogCaptureOpenErrorReason Other { get; } = new("other");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLogCaptureOpenErrorReason"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistryLogCaptureOpenErrorReason left, AgentRegistryLogCaptureOpenErrorReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistryLogCaptureOpenErrorReason"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistryLogCaptureOpenErrorReason left, AgentRegistryLogCaptureOpenErrorReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistryLogCaptureOpenErrorReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistryLogCaptureOpenErrorReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistryLogCaptureOpenErrorReason}"/> for serializing <see cref="AgentRegistryLogCaptureOpenErrorReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistryLogCaptureOpenErrorReason>
    {
        /// <inheritdoc />
        public override AgentRegistryLogCaptureOpenErrorReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistryLogCaptureOpenErrorReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistryLogCaptureOpenErrorReason));
        }
    }
}


/// <summary>Which parameter field was invalid. Omitted when the rejection is not field-specific.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistrySpawnValidationErrorField : IEquatable<AgentRegistrySpawnValidationErrorField>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistrySpawnValidationErrorField"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistrySpawnValidationErrorField"/>.</param>
    [JsonConstructor]
    public AgentRegistrySpawnValidationErrorField(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistrySpawnValidationErrorField"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The cwd parameter.</summary>
    public static AgentRegistrySpawnValidationErrorField Cwd { get; } = new("cwd");

    /// <summary>The session name parameter.</summary>
    public static AgentRegistrySpawnValidationErrorField Name { get; } = new("name");

    /// <summary>The agentName parameter.</summary>
    public static AgentRegistrySpawnValidationErrorField AgentName { get; } = new("agentName");

    /// <summary>The model parameter.</summary>
    public static AgentRegistrySpawnValidationErrorField Model { get; } = new("model");

    /// <summary>The permissionMode parameter.</summary>
    public static AgentRegistrySpawnValidationErrorField PermissionMode { get; } = new("permissionMode");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistrySpawnValidationErrorField"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistrySpawnValidationErrorField left, AgentRegistrySpawnValidationErrorField right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistrySpawnValidationErrorField"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistrySpawnValidationErrorField left, AgentRegistrySpawnValidationErrorField right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistrySpawnValidationErrorField other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistrySpawnValidationErrorField other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistrySpawnValidationErrorField}"/> for serializing <see cref="AgentRegistrySpawnValidationErrorField"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistrySpawnValidationErrorField>
    {
        /// <inheritdoc />
        public override AgentRegistrySpawnValidationErrorField Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistrySpawnValidationErrorField value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistrySpawnValidationErrorField));
        }
    }
}


/// <summary>Categorized reason for the rejection. Low-cardinality enum so telemetry can aggregate by reason without leaking raw paths or agent/model names.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistrySpawnValidationErrorReason : IEquatable<AgentRegistrySpawnValidationErrorReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistrySpawnValidationErrorReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistrySpawnValidationErrorReason"/>.</param>
    [JsonConstructor]
    public AgentRegistrySpawnValidationErrorReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistrySpawnValidationErrorReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Provided cwd does not exist on disk.</summary>
    public static AgentRegistrySpawnValidationErrorReason CwdNotFound { get; } = new("cwd-not-found");

    /// <summary>Provided cwd exists but is not a directory.</summary>
    public static AgentRegistrySpawnValidationErrorReason CwdNotDirectory { get; } = new("cwd-not-directory");

    /// <summary>Session name failed validateSessionName.</summary>
    public static AgentRegistrySpawnValidationErrorReason InvalidName { get; } = new("invalid-name");

    /// <summary>Requested agent name was not found in builtin or custom agents.</summary>
    public static AgentRegistrySpawnValidationErrorReason UnknownAgent { get; } = new("unknown-agent");

    /// <summary>Requested model is not available to this session.</summary>
    public static AgentRegistrySpawnValidationErrorReason UnknownModel { get; } = new("unknown-model");

    /// <summary>Caller asked for permissionMode='yolo' but the controller is not currently in allow-all mode.</summary>
    public static AgentRegistrySpawnValidationErrorReason YoloNotAllowed { get; } = new("yolo-not-allowed");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistrySpawnValidationErrorReason"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistrySpawnValidationErrorReason left, AgentRegistrySpawnValidationErrorReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistrySpawnValidationErrorReason"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistrySpawnValidationErrorReason left, AgentRegistrySpawnValidationErrorReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistrySpawnValidationErrorReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistrySpawnValidationErrorReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistrySpawnValidationErrorReason}"/> for serializing <see cref="AgentRegistrySpawnValidationErrorReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistrySpawnValidationErrorReason>
    {
        /// <inheritdoc />
        public override AgentRegistrySpawnValidationErrorReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistrySpawnValidationErrorReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistrySpawnValidationErrorReason));
        }
    }
}


/// <summary>Permission posture for the new session. 'yolo' requires the controller-local session to currently be in allow-all mode.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AgentRegistrySpawnPermissionMode : IEquatable<AgentRegistrySpawnPermissionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AgentRegistrySpawnPermissionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AgentRegistrySpawnPermissionMode"/>.</param>
    [JsonConstructor]
    public AgentRegistrySpawnPermissionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AgentRegistrySpawnPermissionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Standard permission posture (prompts for each request).</summary>
    public static AgentRegistrySpawnPermissionMode Default { get; } = new("default");

    /// <summary>Full allow-all (requires the controller-local session to currently be in allow-all mode).</summary>
    public static AgentRegistrySpawnPermissionMode Yolo { get; } = new("yolo");

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistrySpawnPermissionMode"/> instances are equivalent.</summary>
    public static bool operator ==(AgentRegistrySpawnPermissionMode left, AgentRegistrySpawnPermissionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AgentRegistrySpawnPermissionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(AgentRegistrySpawnPermissionMode left, AgentRegistrySpawnPermissionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AgentRegistrySpawnPermissionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AgentRegistrySpawnPermissionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AgentRegistrySpawnPermissionMode}"/> for serializing <see cref="AgentRegistrySpawnPermissionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AgentRegistrySpawnPermissionMode>
    {
        /// <inheritdoc />
        public override AgentRegistrySpawnPermissionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AgentRegistrySpawnPermissionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AgentRegistrySpawnPermissionMode));
        }
    }
}


/// <summary>The UI mode the agent was in when this message was sent. Defaults to the session's current mode.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SendAgentMode : IEquatable<SendAgentMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SendAgentMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SendAgentMode"/>.</param>
    [JsonConstructor]
    public SendAgentMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SendAgentMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The agent is responding interactively to the user.</summary>
    public static SendAgentMode Interactive { get; } = new("interactive");

    /// <summary>The agent is preparing a plan before making changes.</summary>
    public static SendAgentMode Plan { get; } = new("plan");

    /// <summary>The agent is working autonomously toward task completion.</summary>
    public static SendAgentMode Autopilot { get; } = new("autopilot");

    /// <summary>The agent is in shell-focused UI mode.</summary>
    public static SendAgentMode Shell { get; } = new("shell");

    /// <summary>Returns a value indicating whether two <see cref="SendAgentMode"/> instances are equivalent.</summary>
    public static bool operator ==(SendAgentMode left, SendAgentMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SendAgentMode"/> instances are not equivalent.</summary>
    public static bool operator !=(SendAgentMode left, SendAgentMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SendAgentMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SendAgentMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SendAgentMode}"/> for serializing <see cref="SendAgentMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SendAgentMode>
    {
        /// <inheritdoc />
        public override SendAgentMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SendAgentMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SendAgentMode));
        }
    }
}


/// <summary>How to deliver the message. `enqueue` (default) appends to the message queue. `immediate` interjects during an in-progress turn.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SendMode : IEquatable<SendMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SendMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SendMode"/>.</param>
    [JsonConstructor]
    public SendMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SendMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Append the message to the normal session queue.</summary>
    public static SendMode Enqueue { get; } = new("enqueue");

    /// <summary>Interject the message during the in-progress turn.</summary>
    public static SendMode Immediate { get; } = new("immediate");

    /// <summary>Returns a value indicating whether two <see cref="SendMode"/> instances are equivalent.</summary>
    public static bool operator ==(SendMode left, SendMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SendMode"/> instances are not equivalent.</summary>
    public static bool operator !=(SendMode left, SendMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SendMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SendMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SendMode}"/> for serializing <see cref="SendMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SendMode>
    {
        /// <inheritdoc />
        public override SendMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SendMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SendMode));
        }
    }
}


/// <summary>Log severity level. Determines how the message is displayed in the timeline. Defaults to "info".</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionLogLevel : IEquatable<SessionLogLevel>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionLogLevel"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionLogLevel"/>.</param>
    [JsonConstructor]
    public SessionLogLevel(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionLogLevel"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Informational message.</summary>
    public static SessionLogLevel Info { get; } = new("info");

    /// <summary>Warning message that may require attention.</summary>
    public static SessionLogLevel Warning { get; } = new("warning");

    /// <summary>Error message describing a failure.</summary>
    public static SessionLogLevel Error { get; } = new("error");

    /// <summary>Returns a value indicating whether two <see cref="SessionLogLevel"/> instances are equivalent.</summary>
    public static bool operator ==(SessionLogLevel left, SessionLogLevel right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionLogLevel"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionLogLevel left, SessionLogLevel right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionLogLevel other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionLogLevel other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionLogLevel}"/> for serializing <see cref="SessionLogLevel"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionLogLevel>
    {
        /// <inheritdoc />
        public override SessionLogLevel Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionLogLevel value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionLogLevel));
        }
    }
}


/// <summary>Disposition of a permission request as observed by the responding client.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionDecisionOutcome : IEquatable<PermissionDecisionOutcome>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionDecisionOutcome"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionDecisionOutcome"/>.</param>
    [JsonConstructor]
    public PermissionDecisionOutcome(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionDecisionOutcome"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The request was approved automatically without a new human decision.</summary>
    public static PermissionDecisionOutcome AutoApproved { get; } = new("auto_approved");

    /// <summary>The request was denied without an interactive user decision; source records why.</summary>
    public static PermissionDecisionOutcome AutopilotDenied { get; } = new("autopilot_denied");

    /// <summary>The response came from an interactive user prompt.</summary>
    public static PermissionDecisionOutcome PromptedUser { get; } = new("prompted_user");

    /// <summary>Returns a value indicating whether two <see cref="PermissionDecisionOutcome"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionDecisionOutcome left, PermissionDecisionOutcome right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionDecisionOutcome"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionDecisionOutcome left, PermissionDecisionOutcome right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionDecisionOutcome other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionDecisionOutcome other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionDecisionOutcome}"/> for serializing <see cref="PermissionDecisionOutcome"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionDecisionOutcome>
    {
        /// <inheritdoc />
        public override PermissionDecisionOutcome Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionDecisionOutcome value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionDecisionOutcome));
        }
    }
}


/// <summary>Response capability available to the client when it settled a permission request.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionResponseCapability : IEquatable<PermissionResponseCapability>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionResponseCapability"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionResponseCapability"/>.</param>
    [JsonConstructor]
    public PermissionResponseCapability(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionResponseCapability"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The client could ask a user for this decision.</summary>
    public static PermissionResponseCapability Interactive { get; } = new("interactive");

    /// <summary>The client could return an automated response but could not ask a user.</summary>
    public static PermissionResponseCapability Headless { get; } = new("headless");

    /// <summary>The client had no response path available.</summary>
    public static PermissionResponseCapability None { get; } = new("none");

    /// <summary>Returns a value indicating whether two <see cref="PermissionResponseCapability"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionResponseCapability left, PermissionResponseCapability right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionResponseCapability"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionResponseCapability left, PermissionResponseCapability right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionResponseCapability other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionResponseCapability other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionResponseCapability}"/> for serializing <see cref="PermissionResponseCapability"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionResponseCapability>
    {
        /// <inheritdoc />
        public override PermissionResponseCapability Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionResponseCapability value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionResponseCapability));
        }
    }
}


/// <summary>Controlled reason or actor responsible for a permission response.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionDecisionSource : IEquatable<PermissionDecisionSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionDecisionSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionDecisionSource"/>.</param>
    [JsonConstructor]
    public PermissionDecisionSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionDecisionSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The response followed the assisted-approval judge recommendation.</summary>
    public static PermissionDecisionSource AssistedApproval { get; } = new("assisted_approval");

    /// <summary>A human supplied the response through an interactive prompt.</summary>
    public static PermissionDecisionSource HumanResponse { get; } = new("human_response");

    /// <summary>The host applied a standing policy or override rather than a judge recommendation or human decision.</summary>
    public static PermissionDecisionSource HostPolicy { get; } = new("host_policy");

    /// <summary>The host denied the request because no interactive user response was available.</summary>
    public static PermissionDecisionSource UnattendedFallback { get; } = new("unattended_fallback");

    /// <summary>Returns a value indicating whether two <see cref="PermissionDecisionSource"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionDecisionSource left, PermissionDecisionSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionDecisionSource"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionDecisionSource left, PermissionDecisionSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionDecisionSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionDecisionSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionDecisionSource}"/> for serializing <see cref="PermissionDecisionSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionDecisionSource>
    {
        /// <inheritdoc />
        public override PermissionDecisionSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionDecisionSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionDecisionSource));
        }
    }
}


/// <summary>Client surface that submitted a permission response.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionDecisionSurface : IEquatable<PermissionDecisionSurface>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionDecisionSurface"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionDecisionSurface"/>.</param>
    [JsonConstructor]
    public PermissionDecisionSurface(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionDecisionSurface"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The interactive Copilot CLI terminal UI.</summary>
    public static PermissionDecisionSurface Tui { get; } = new("tui");

    /// <summary>The non-interactive Copilot CLI prompt mode.</summary>
    public static PermissionDecisionSurface PromptMode { get; } = new("prompt_mode");

    /// <summary>The Copilot App client.</summary>
    public static PermissionDecisionSurface CopilotApp { get; } = new("copilot_app");

    /// <summary>An Agent Client Protocol host.</summary>
    public static PermissionDecisionSurface Acp { get; } = new("acp");

    /// <summary>A generic Copilot SDK client.</summary>
    public static PermissionDecisionSurface Sdk { get; } = new("sdk");

    /// <summary>Returns a value indicating whether two <see cref="PermissionDecisionSurface"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionDecisionSurface left, PermissionDecisionSurface right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionDecisionSurface"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionDecisionSurface left, PermissionDecisionSurface right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionDecisionSurface other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionDecisionSurface other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionDecisionSurface}"/> for serializing <see cref="PermissionDecisionSurface"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionDecisionSurface>
    {
        /// <inheritdoc />
        public override PermissionDecisionSurface Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionDecisionSurface value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionDecisionSurface));
        }
    }
}


/// <summary>Authentication type.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AuthInfoType : IEquatable<AuthInfoType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AuthInfoType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AuthInfoType"/>.</param>
    [JsonConstructor]
    public AuthInfoType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AuthInfoType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Authentication provided by a GitHub App HMAC credential.</summary>
    public static AuthInfoType Hmac { get; } = new("hmac");

    /// <summary>Authentication resolved from environment-provided credentials.</summary>
    public static AuthInfoType Env { get; } = new("env");

    /// <summary>Authentication from an interactive user sign-in.</summary>
    public static AuthInfoType User { get; } = new("user");

    /// <summary>Authentication delegated to the GitHub CLI.</summary>
    public static AuthInfoType GhCli { get; } = new("gh-cli");

    /// <summary>Authentication from an API key credential.</summary>
    public static AuthInfoType ApiKey { get; } = new("api-key");

    /// <summary>Authentication from a GitHub token.</summary>
    public static AuthInfoType Token { get; } = new("token");

    /// <summary>Authentication from an SDK GitHub token callback.</summary>
    public static AuthInfoType TokenProvider { get; } = new("token-provider");

    /// <summary>Authentication from a Copilot API token.</summary>
    public static AuthInfoType CopilotApiToken { get; } = new("copilot-api-token");

    /// <summary>Returns a value indicating whether two <see cref="AuthInfoType"/> instances are equivalent.</summary>
    public static bool operator ==(AuthInfoType left, AuthInfoType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AuthInfoType"/> instances are not equivalent.</summary>
    public static bool operator !=(AuthInfoType left, AuthInfoType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AuthInfoType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AuthInfoType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AuthInfoType}"/> for serializing <see cref="AuthInfoType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AuthInfoType>
    {
        /// <inheritdoc />
        public override AuthInfoType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AuthInfoType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AuthInfoType));
        }
    }
}


/// <summary>Source category for a collected debug bundle entry.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct DebugCollectLogsSource : IEquatable<DebugCollectLogsSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="DebugCollectLogsSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="DebugCollectLogsSource"/>.</param>
    [JsonConstructor]
    public DebugCollectLogsSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="DebugCollectLogsSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Session event log.</summary>
    public static DebugCollectLogsSource Events { get; } = new("events");

    /// <summary>Process log for the session.</summary>
    public static DebugCollectLogsSource ProcessLog { get; } = new("process-log");

    /// <summary>Interactive shell log for the session.</summary>
    public static DebugCollectLogsSource ShellLog { get; } = new("shell-log");

    /// <summary>Caller-provided diagnostic entry.</summary>
    public static DebugCollectLogsSource Additional { get; } = new("additional");

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsSource"/> instances are equivalent.</summary>
    public static bool operator ==(DebugCollectLogsSource left, DebugCollectLogsSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsSource"/> instances are not equivalent.</summary>
    public static bool operator !=(DebugCollectLogsSource left, DebugCollectLogsSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is DebugCollectLogsSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(DebugCollectLogsSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{DebugCollectLogsSource}"/> for serializing <see cref="DebugCollectLogsSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<DebugCollectLogsSource>
    {
        /// <inheritdoc />
        public override DebugCollectLogsSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, DebugCollectLogsSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(DebugCollectLogsSource));
        }
    }
}


/// <summary>Destination kind that was written.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct DebugCollectLogsResultKind : IEquatable<DebugCollectLogsResultKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="DebugCollectLogsResultKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="DebugCollectLogsResultKind"/>.</param>
    [JsonConstructor]
    public DebugCollectLogsResultKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="DebugCollectLogsResultKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A .tgz archive was written.</summary>
    public static DebugCollectLogsResultKind Archive { get; } = new("archive");

    /// <summary>A directory containing redacted files was written.</summary>
    public static DebugCollectLogsResultKind Directory { get; } = new("directory");

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsResultKind"/> instances are equivalent.</summary>
    public static bool operator ==(DebugCollectLogsResultKind left, DebugCollectLogsResultKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsResultKind"/> instances are not equivalent.</summary>
    public static bool operator !=(DebugCollectLogsResultKind left, DebugCollectLogsResultKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is DebugCollectLogsResultKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(DebugCollectLogsResultKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{DebugCollectLogsResultKind}"/> for serializing <see cref="DebugCollectLogsResultKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<DebugCollectLogsResultKind>
    {
        /// <inheritdoc />
        public override DebugCollectLogsResultKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, DebugCollectLogsResultKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(DebugCollectLogsResultKind));
        }
    }
}


/// <summary>Kind of caller-provided debug log entry.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct DebugCollectLogsEntryKind : IEquatable<DebugCollectLogsEntryKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="DebugCollectLogsEntryKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="DebugCollectLogsEntryKind"/>.</param>
    [JsonConstructor]
    public DebugCollectLogsEntryKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="DebugCollectLogsEntryKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Include a single server-local file.</summary>
    public static DebugCollectLogsEntryKind File { get; } = new("file");

    /// <summary>Include files from a server-local directory recursively.</summary>
    public static DebugCollectLogsEntryKind Directory { get; } = new("directory");

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsEntryKind"/> instances are equivalent.</summary>
    public static bool operator ==(DebugCollectLogsEntryKind left, DebugCollectLogsEntryKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsEntryKind"/> instances are not equivalent.</summary>
    public static bool operator !=(DebugCollectLogsEntryKind left, DebugCollectLogsEntryKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is DebugCollectLogsEntryKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(DebugCollectLogsEntryKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{DebugCollectLogsEntryKind}"/> for serializing <see cref="DebugCollectLogsEntryKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<DebugCollectLogsEntryKind>
    {
        /// <inheritdoc />
        public override DebugCollectLogsEntryKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, DebugCollectLogsEntryKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(DebugCollectLogsEntryKind));
        }
    }
}


/// <summary>How a collected debug entry should be redacted before being staged.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct DebugCollectLogsRedaction : IEquatable<DebugCollectLogsRedaction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="DebugCollectLogsRedaction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="DebugCollectLogsRedaction"/>.</param>
    [JsonConstructor]
    public DebugCollectLogsRedaction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="DebugCollectLogsRedaction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Redact the file as plain UTF-8 log text.</summary>
    public static DebugCollectLogsRedaction PlainText { get; } = new("plain-text");

    /// <summary>Redact each non-empty line as a session event JSON object, falling back to plain-text redaction for malformed lines.</summary>
    public static DebugCollectLogsRedaction EventsJsonl { get; } = new("events-jsonl");

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsRedaction"/> instances are equivalent.</summary>
    public static bool operator ==(DebugCollectLogsRedaction left, DebugCollectLogsRedaction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="DebugCollectLogsRedaction"/> instances are not equivalent.</summary>
    public static bool operator !=(DebugCollectLogsRedaction left, DebugCollectLogsRedaction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is DebugCollectLogsRedaction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(DebugCollectLogsRedaction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{DebugCollectLogsRedaction}"/> for serializing <see cref="DebugCollectLogsRedaction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<DebugCollectLogsRedaction>
    {
        /// <inheritdoc />
        public override DebugCollectLogsRedaction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, DebugCollectLogsRedaction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(DebugCollectLogsRedaction));
        }
    }
}


/// <summary>Cumulative resource ceiling that stopped a factory run.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryRunFailureKind : IEquatable<FactoryRunFailureKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryRunFailureKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryRunFailureKind"/>.</param>
    [JsonConstructor]
    public FactoryRunFailureKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryRunFailureKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The run admitted the approved maximum total number of subagents.</summary>
    public static FactoryRunFailureKind MaxTotalSubagents { get; } = new("maxTotalSubagents");

    /// <summary>The run reached the approved accumulated active-execution time in seconds.</summary>
    public static FactoryRunFailureKind TimeoutSeconds { get; } = new("timeoutSeconds");

    /// <summary>The run's settled subagent model usage exceeded the approved AI-credit ceiling, or no headroom remained for another subagent.</summary>
    public static FactoryRunFailureKind MaxAiCredits { get; } = new("maxAiCredits");

    /// <summary>Returns a value indicating whether two <see cref="FactoryRunFailureKind"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryRunFailureKind left, FactoryRunFailureKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryRunFailureKind"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryRunFailureKind left, FactoryRunFailureKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryRunFailureKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryRunFailureKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryRunFailureKind}"/> for serializing <see cref="FactoryRunFailureKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryRunFailureKind>
    {
        /// <inheritdoc />
        public override FactoryRunFailureKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryRunFailureKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryRunFailureKind));
        }
    }
}


/// <summary>Execution-critical factory storage operation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryDurableOperation : IEquatable<FactoryDurableOperation>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryDurableOperation"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryDurableOperation"/>.</param>
    [JsonConstructor]
    public FactoryDurableOperation(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryDurableOperation"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Creating the durable run and declared phases.</summary>
    public static FactoryDurableOperation CreateRun { get; } = new("createRun");

    /// <summary>Persisting the transition to running.</summary>
    public static FactoryDurableOperation MarkRunStarted { get; } = new("markRunStarted");

    /// <summary>Persisting the terminal run envelope.</summary>
    public static FactoryDurableOperation FinishRun { get; } = new("finishRun");

    /// <summary>Persisting subagent admission accounting.</summary>
    public static FactoryDurableOperation ReserveAgent { get; } = new("reserveAgent");

    /// <summary>Rolling back an uncommitted subagent admission.</summary>
    public static FactoryDurableOperation ReleaseAgent { get; } = new("releaseAgent");

    /// <summary>Persisting an idempotent model-usage charge.</summary>
    public static FactoryDurableOperation ChargeCredit { get; } = new("chargeCredit");

    /// <summary>Persisting active execution time.</summary>
    public static FactoryDurableOperation AddElapsed { get; } = new("addElapsed");

    /// <summary>Reading the authoritative AI-credit total.</summary>
    public static FactoryDurableOperation ReconcileCreditTotal { get; } = new("reconcileCreditTotal");

    /// <summary>Reading a journal entry without treating storage failure as a cache miss.</summary>
    public static FactoryDurableOperation JournalGet { get; } = new("journalGet");

    /// <summary>Persisting a journal entry before reporting success.</summary>
    public static FactoryDurableOperation JournalPut { get; } = new("journalPut");

    /// <summary>Renewing the durable owner lease that proves this process still owns the run.</summary>
    public static FactoryDurableOperation RefreshLease { get; } = new("refreshLease");

    /// <summary>Returns a value indicating whether two <see cref="FactoryDurableOperation"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryDurableOperation left, FactoryDurableOperation right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryDurableOperation"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryDurableOperation left, FactoryDurableOperation right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryDurableOperation other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryDurableOperation other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryDurableOperation}"/> for serializing <see cref="FactoryDurableOperation"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryDurableOperation>
    {
        /// <inheritdoc />
        public override FactoryDurableOperation Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryDurableOperation value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryDurableOperation));
        }
    }
}


/// <summary>Current or terminal state of a factory run.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryRunStatus : IEquatable<FactoryRunStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryRunStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryRunStatus"/>.</param>
    [JsonConstructor]
    public FactoryRunStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryRunStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The run was minted and is awaiting approval.</summary>
    public static FactoryRunStatus Pending { get; } = new("pending");

    /// <summary>The run is executing.</summary>
    public static FactoryRunStatus Running { get; } = new("running");

    /// <summary>The run completed successfully.</summary>
    public static FactoryRunStatus Completed { get; } = new("completed");

    /// <summary>The run was interrupted while resource budget remained.</summary>
    public static FactoryRunStatus Halted { get; } = new("halted");

    /// <summary>The current attempt stopped intentionally and the run may be resumed.</summary>
    public static FactoryRunStatus Paused { get; } = new("paused");

    /// <summary>The run was cancelled before completion.</summary>
    public static FactoryRunStatus Cancelled { get; } = new("cancelled");

    /// <summary>The factory body failed or reached a cumulative resource ceiling.</summary>
    public static FactoryRunStatus Error { get; } = new("error");

    /// <summary>Returns a value indicating whether two <see cref="FactoryRunStatus"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryRunStatus left, FactoryRunStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryRunStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryRunStatus left, FactoryRunStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryRunStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryRunStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryRunStatus}"/> for serializing <see cref="FactoryRunStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryRunStatus>
    {
        /// <inheritdoc />
        public override FactoryRunStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryRunStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryRunStatus));
        }
    }
}


/// <summary>Derived lifecycle state of a factory phase.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryPhaseStatus : IEquatable<FactoryPhaseStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryPhaseStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryPhaseStatus"/>.</param>
    [JsonConstructor]
    public FactoryPhaseStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryPhaseStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The phase has not been entered yet.</summary>
    public static FactoryPhaseStatus Pending { get; } = new("pending");

    /// <summary>The phase is currently entered and accumulating active time.</summary>
    public static FactoryPhaseStatus Active { get; } = new("active");

    /// <summary>The phase was entered and has since been closed.</summary>
    public static FactoryPhaseStatus Completed { get; } = new("completed");

    /// <summary>The phase was never entered because a later phase was entered or the run reached a terminal state.</summary>
    public static FactoryPhaseStatus Skipped { get; } = new("skipped");

    /// <summary>Returns a value indicating whether two <see cref="FactoryPhaseStatus"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryPhaseStatus left, FactoryPhaseStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryPhaseStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryPhaseStatus left, FactoryPhaseStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryPhaseStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryPhaseStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryPhaseStatus}"/> for serializing <see cref="FactoryPhaseStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryPhaseStatus>
    {
        /// <inheritdoc />
        public override FactoryPhaseStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryPhaseStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryPhaseStatus));
        }
    }
}


/// <summary>Kind of factory progress line.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryLogLineKind : IEquatable<FactoryLogLineKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryLogLineKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryLogLineKind"/>.</param>
    [JsonConstructor]
    public FactoryLogLineKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryLogLineKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A narrator log line.</summary>
    public static FactoryLogLineKind Log { get; } = new("log");

    /// <summary>A named factory phase marker.</summary>
    public static FactoryLogLineKind Phase { get; } = new("phase");

    /// <summary>Returns a value indicating whether two <see cref="FactoryLogLineKind"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryLogLineKind left, FactoryLogLineKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryLogLineKind"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryLogLineKind left, FactoryLogLineKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryLogLineKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryLogLineKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryLogLineKind}"/> for serializing <see cref="FactoryLogLineKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryLogLineKind>
    {
        /// <inheritdoc />
        public override FactoryLogLineKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryLogLineKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryLogLineKind));
        }
    }
}


/// <summary>Action the runtime selected for a durable factory pause checkpoint.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct FactoryPauseCheckpointAction : IEquatable<FactoryPauseCheckpointAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="FactoryPauseCheckpointAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="FactoryPauseCheckpointAction"/>.</param>
    [JsonConstructor]
    public FactoryPauseCheckpointAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="FactoryPauseCheckpointAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The checkpoint was committed by a prior paused attempt, so execution may continue.</summary>
    public static FactoryPauseCheckpointAction Continue { get; } = new("continue");

    /// <summary>This attempt claimed the checkpoint and must cooperatively stop.</summary>
    public static FactoryPauseCheckpointAction Pause { get; } = new("pause");

    /// <summary>Returns a value indicating whether two <see cref="FactoryPauseCheckpointAction"/> instances are equivalent.</summary>
    public static bool operator ==(FactoryPauseCheckpointAction left, FactoryPauseCheckpointAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="FactoryPauseCheckpointAction"/> instances are not equivalent.</summary>
    public static bool operator !=(FactoryPauseCheckpointAction left, FactoryPauseCheckpointAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is FactoryPauseCheckpointAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(FactoryPauseCheckpointAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{FactoryPauseCheckpointAction}"/> for serializing <see cref="FactoryPauseCheckpointAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<FactoryPauseCheckpointAction>
    {
        /// <inheritdoc />
        public override FactoryPauseCheckpointAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, FactoryPauseCheckpointAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(FactoryPauseCheckpointAction));
        }
    }
}


/// <summary>Whether the requested preference was already effective or was accepted for later transactional activation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ModelSwitchAutoTierStatus : IEquatable<ModelSwitchAutoTierStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ModelSwitchAutoTierStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ModelSwitchAutoTierStatus"/>.</param>
    [JsonConstructor]
    public ModelSwitchAutoTierStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ModelSwitchAutoTierStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The requested preference is already effective. No activation is pending for it, although this request may have cancelled an earlier unclaimed preference reported in `supersededAutoTier`.</summary>
    public static ModelSwitchAutoTierStatus Unchanged { get; } = new("unchanged");

    /// <summary>The request was accepted but has not committed. A later user turn using the `auto` model must mint and validate the replacement before it becomes effective.</summary>
    public static ModelSwitchAutoTierStatus Pending { get; } = new("pending");

    /// <summary>Returns a value indicating whether two <see cref="ModelSwitchAutoTierStatus"/> instances are equivalent.</summary>
    public static bool operator ==(ModelSwitchAutoTierStatus left, ModelSwitchAutoTierStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ModelSwitchAutoTierStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(ModelSwitchAutoTierStatus left, ModelSwitchAutoTierStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ModelSwitchAutoTierStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ModelSwitchAutoTierStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ModelSwitchAutoTierStatus}"/> for serializing <see cref="ModelSwitchAutoTierStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ModelSwitchAutoTierStatus>
    {
        /// <inheritdoc />
        public override ModelSwitchAutoTierStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ModelSwitchAutoTierStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ModelSwitchAutoTierStatus));
        }
    }
}


/// <summary>Allowed values for the `WorkspacesWorkspaceDetailsHostType` enumeration.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct WorkspacesWorkspaceDetailsHostType : IEquatable<WorkspacesWorkspaceDetailsHostType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="WorkspacesWorkspaceDetailsHostType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="WorkspacesWorkspaceDetailsHostType"/>.</param>
    [JsonConstructor]
    public WorkspacesWorkspaceDetailsHostType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="WorkspacesWorkspaceDetailsHostType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Workspace repository is hosted on GitHub.</summary>
    public static WorkspacesWorkspaceDetailsHostType GitHub { get; } = new("github");

    /// <summary>Workspace repository is hosted on Azure DevOps.</summary>
    public static WorkspacesWorkspaceDetailsHostType Ado { get; } = new("ado");

    /// <summary>Returns a value indicating whether two <see cref="WorkspacesWorkspaceDetailsHostType"/> instances are equivalent.</summary>
    public static bool operator ==(WorkspacesWorkspaceDetailsHostType left, WorkspacesWorkspaceDetailsHostType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="WorkspacesWorkspaceDetailsHostType"/> instances are not equivalent.</summary>
    public static bool operator !=(WorkspacesWorkspaceDetailsHostType left, WorkspacesWorkspaceDetailsHostType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is WorkspacesWorkspaceDetailsHostType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(WorkspacesWorkspaceDetailsHostType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{WorkspacesWorkspaceDetailsHostType}"/> for serializing <see cref="WorkspacesWorkspaceDetailsHostType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<WorkspacesWorkspaceDetailsHostType>
    {
        /// <inheritdoc />
        public override WorkspacesWorkspaceDetailsHostType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, WorkspacesWorkspaceDetailsHostType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(WorkspacesWorkspaceDetailsHostType));
        }
    }
}


/// <summary>Type of change represented by this file diff.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct WorkspaceDiffFileChangeType : IEquatable<WorkspaceDiffFileChangeType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="WorkspaceDiffFileChangeType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="WorkspaceDiffFileChangeType"/>.</param>
    [JsonConstructor]
    public WorkspaceDiffFileChangeType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="WorkspaceDiffFileChangeType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The file was added.</summary>
    public static WorkspaceDiffFileChangeType Added { get; } = new("added");

    /// <summary>The file was modified.</summary>
    public static WorkspaceDiffFileChangeType Modified { get; } = new("modified");

    /// <summary>The file was deleted.</summary>
    public static WorkspaceDiffFileChangeType Deleted { get; } = new("deleted");

    /// <summary>The file was renamed.</summary>
    public static WorkspaceDiffFileChangeType Renamed { get; } = new("renamed");

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceDiffFileChangeType"/> instances are equivalent.</summary>
    public static bool operator ==(WorkspaceDiffFileChangeType left, WorkspaceDiffFileChangeType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceDiffFileChangeType"/> instances are not equivalent.</summary>
    public static bool operator !=(WorkspaceDiffFileChangeType left, WorkspaceDiffFileChangeType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is WorkspaceDiffFileChangeType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(WorkspaceDiffFileChangeType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{WorkspaceDiffFileChangeType}"/> for serializing <see cref="WorkspaceDiffFileChangeType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<WorkspaceDiffFileChangeType>
    {
        /// <inheritdoc />
        public override WorkspaceDiffFileChangeType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, WorkspaceDiffFileChangeType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(WorkspaceDiffFileChangeType));
        }
    }
}


/// <summary>Diff mode requested by the client.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct WorkspaceDiffMode : IEquatable<WorkspaceDiffMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="WorkspaceDiffMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="WorkspaceDiffMode"/>.</param>
    [JsonConstructor]
    public WorkspaceDiffMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="WorkspaceDiffMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Return staged, unstaged, and untracked working tree changes.</summary>
    public static WorkspaceDiffMode Unstaged { get; } = new("unstaged");

    /// <summary>Return changes compared with the default branch.</summary>
    public static WorkspaceDiffMode Branch { get; } = new("branch");

    /// <summary>Return the cumulative diff of files Copilot changed this session (used in non-git workspaces).</summary>
    public static WorkspaceDiffMode Session { get; } = new("session");

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceDiffMode"/> instances are equivalent.</summary>
    public static bool operator ==(WorkspaceDiffMode left, WorkspaceDiffMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceDiffMode"/> instances are not equivalent.</summary>
    public static bool operator !=(WorkspaceDiffMode left, WorkspaceDiffMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is WorkspaceDiffMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(WorkspaceDiffMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{WorkspaceDiffMode}"/> for serializing <see cref="WorkspaceDiffMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<WorkspaceDiffMode>
    {
        /// <inheritdoc />
        public override WorkspaceDiffMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, WorkspaceDiffMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(WorkspaceDiffMode));
        }
    }
}


/// <summary>Reason a rewind read (rewind points, file-restore preview, or session diff) could not be answered from the session's file-change captures.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HistoryRewindUnavailableReason : IEquatable<HistoryRewindUnavailableReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HistoryRewindUnavailableReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HistoryRewindUnavailableReason"/>.</param>
    [JsonConstructor]
    public HistoryRewindUnavailableReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HistoryRewindUnavailableReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The session did not opt into file-change tracking before its first turn.</summary>
    public static HistoryRewindUnavailableReason FileChangeTrackingDisabled { get; } = new("file-change-tracking-disabled");

    /// <summary>The session still has work that may mutate files or history. Transient: the same request succeeds once the session settles, so callers should retry rather than treat it as a failure.</summary>
    public static HistoryRewindUnavailableReason SessionBusy { get; } = new("session-busy");

    /// <summary>Remote-backed rewind routing is not supported.</summary>
    public static HistoryRewindUnavailableReason UnsupportedRemoteSession { get; } = new("unsupported-remote-session");

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindUnavailableReason"/> instances are equivalent.</summary>
    public static bool operator ==(HistoryRewindUnavailableReason left, HistoryRewindUnavailableReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindUnavailableReason"/> instances are not equivalent.</summary>
    public static bool operator !=(HistoryRewindUnavailableReason left, HistoryRewindUnavailableReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HistoryRewindUnavailableReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HistoryRewindUnavailableReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HistoryRewindUnavailableReason}"/> for serializing <see cref="HistoryRewindUnavailableReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HistoryRewindUnavailableReason>
    {
        /// <inheritdoc />
        public override HistoryRewindUnavailableReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HistoryRewindUnavailableReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HistoryRewindUnavailableReason));
        }
    }
}


/// <summary>Current normalized autopilot objective lifecycle status.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct AutopilotObjectiveStatus : IEquatable<AutopilotObjectiveStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="AutopilotObjectiveStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="AutopilotObjectiveStatus"/>.</param>
    [JsonConstructor]
    public AutopilotObjectiveStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="AutopilotObjectiveStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The objective is actively running.</summary>
    public static AutopilotObjectiveStatus Active { get; } = new("active");

    /// <summary>The objective is paused and may be resumed.</summary>
    public static AutopilotObjectiveStatus Paused { get; } = new("paused");

    /// <summary>The objective completed.</summary>
    public static AutopilotObjectiveStatus Completed { get; } = new("completed");

    /// <summary>Returns a value indicating whether two <see cref="AutopilotObjectiveStatus"/> instances are equivalent.</summary>
    public static bool operator ==(AutopilotObjectiveStatus left, AutopilotObjectiveStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="AutopilotObjectiveStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(AutopilotObjectiveStatus left, AutopilotObjectiveStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is AutopilotObjectiveStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(AutopilotObjectiveStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{AutopilotObjectiveStatus}"/> for serializing <see cref="AutopilotObjectiveStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<AutopilotObjectiveStatus>
    {
        /// <inheritdoc />
        public override AutopilotObjectiveStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, AutopilotObjectiveStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(AutopilotObjectiveStatus));
        }
    }
}


/// <summary>Whether task execution is synchronously awaited or managed in the background.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskExecutionMode : IEquatable<TaskExecutionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskExecutionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskExecutionMode"/>.</param>
    [JsonConstructor]
    public TaskExecutionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskExecutionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The task was started with synchronous waiting.</summary>
    public static TaskExecutionMode Sync { get; } = new("sync");

    /// <summary>The task is managed in the background.</summary>
    public static TaskExecutionMode Background { get; } = new("background");

    /// <summary>Returns a value indicating whether two <see cref="TaskExecutionMode"/> instances are equivalent.</summary>
    public static bool operator ==(TaskExecutionMode left, TaskExecutionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskExecutionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskExecutionMode left, TaskExecutionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskExecutionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskExecutionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskExecutionMode}"/> for serializing <see cref="TaskExecutionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskExecutionMode>
    {
        /// <inheritdoc />
        public override TaskExecutionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskExecutionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskExecutionMode));
        }
    }
}


/// <summary>Current lifecycle status of the task.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskStatus : IEquatable<TaskStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskStatus"/>.</param>
    [JsonConstructor]
    public TaskStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The task is actively executing.</summary>
    public static TaskStatus Running { get; } = new("running");

    /// <summary>The task is waiting for additional input.</summary>
    public static TaskStatus Idle { get; } = new("idle");

    /// <summary>The task finished successfully.</summary>
    public static TaskStatus Completed { get; } = new("completed");

    /// <summary>The task finished with an error.</summary>
    public static TaskStatus Failed { get; } = new("failed");

    /// <summary>The task was cancelled before completion.</summary>
    public static TaskStatus Cancelled { get; } = new("cancelled");

    /// <summary>Returns a value indicating whether two <see cref="TaskStatus"/> instances are equivalent.</summary>
    public static bool operator ==(TaskStatus left, TaskStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskStatus left, TaskStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskStatus}"/> for serializing <see cref="TaskStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskStatus>
    {
        /// <inheritdoc />
        public override TaskStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskStatus));
        }
    }
}


/// <summary>Client-owned tasks always execute outside the runtime in background mode.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskClientExecutionMode : IEquatable<TaskClientExecutionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskClientExecutionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskClientExecutionMode"/>.</param>
    [JsonConstructor]
    public TaskClientExecutionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskClientExecutionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Gets the <c>background</c> value.</summary>
    public static TaskClientExecutionMode Background { get; } = new("background");

    /// <summary>Returns a value indicating whether two <see cref="TaskClientExecutionMode"/> instances are equivalent.</summary>
    public static bool operator ==(TaskClientExecutionMode left, TaskClientExecutionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskClientExecutionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskClientExecutionMode left, TaskClientExecutionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskClientExecutionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskClientExecutionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskClientExecutionMode}"/> for serializing <see cref="TaskClientExecutionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskClientExecutionMode>
    {
        /// <inheritdoc />
        public override TaskClientExecutionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskClientExecutionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskClientExecutionMode));
        }
    }
}


/// <summary>Connection class owning a client task.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskClientOwnerKind : IEquatable<TaskClientOwnerKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskClientOwnerKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskClientOwnerKind"/>.</param>
    [JsonConstructor]
    public TaskClientOwnerKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskClientOwnerKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A discovered extension connection owns the task.</summary>
    public static TaskClientOwnerKind Extension { get; } = new("extension");

    /// <summary>A generic SDK connection owns the task.</summary>
    public static TaskClientOwnerKind Sdk { get; } = new("sdk");

    /// <summary>Returns a value indicating whether two <see cref="TaskClientOwnerKind"/> instances are equivalent.</summary>
    public static bool operator ==(TaskClientOwnerKind left, TaskClientOwnerKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskClientOwnerKind"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskClientOwnerKind left, TaskClientOwnerKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskClientOwnerKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskClientOwnerKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskClientOwnerKind}"/> for serializing <see cref="TaskClientOwnerKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskClientOwnerKind>
    {
        /// <inheritdoc />
        public override TaskClientOwnerKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskClientOwnerKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskClientOwnerKind));
        }
    }
}


/// <summary>Presence of the task's bound join.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskClientOwnerPresence : IEquatable<TaskClientOwnerPresence>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskClientOwnerPresence"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskClientOwnerPresence"/>.</param>
    [JsonConstructor]
    public TaskClientOwnerPresence(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskClientOwnerPresence"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The bound session join is connected.</summary>
    public static TaskClientOwnerPresence Connected { get; } = new("connected");

    /// <summary>The bound session join is disconnected.</summary>
    public static TaskClientOwnerPresence Disconnected { get; } = new("disconnected");

    /// <summary>Returns a value indicating whether two <see cref="TaskClientOwnerPresence"/> instances are equivalent.</summary>
    public static bool operator ==(TaskClientOwnerPresence left, TaskClientOwnerPresence right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskClientOwnerPresence"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskClientOwnerPresence left, TaskClientOwnerPresence right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskClientOwnerPresence other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskClientOwnerPresence other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskClientOwnerPresence}"/> for serializing <see cref="TaskClientOwnerPresence"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskClientOwnerPresence>
    {
        /// <inheritdoc />
        public override TaskClientOwnerPresence Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskClientOwnerPresence value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskClientOwnerPresence));
        }
    }
}


/// <summary>Lifecycle status of a client-owned task.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskClientStatus : IEquatable<TaskClientStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskClientStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskClientStatus"/>.</param>
    [JsonConstructor]
    public TaskClientStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskClientStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The external owner is actively working.</summary>
    public static TaskClientStatus Running { get; } = new("running");

    /// <summary>The external owner is connected but waiting.</summary>
    public static TaskClientStatus Idle { get; } = new("idle");

    /// <summary>The owner reported successful completion.</summary>
    public static TaskClientStatus Completed { get; } = new("completed");

    /// <summary>The owner reported failure.</summary>
    public static TaskClientStatus Failed { get; } = new("failed");

    /// <summary>The owner reported or confirmed cancellation.</summary>
    public static TaskClientStatus Cancelled { get; } = new("cancelled");

    /// <summary>The bound owner join disappeared; external executor state is unknown.</summary>
    public static TaskClientStatus Orphaned { get; } = new("orphaned");

    /// <summary>Returns a value indicating whether two <see cref="TaskClientStatus"/> instances are equivalent.</summary>
    public static bool operator ==(TaskClientStatus left, TaskClientStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskClientStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskClientStatus left, TaskClientStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskClientStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskClientStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskClientStatus}"/> for serializing <see cref="TaskClientStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskClientStatus>
    {
        /// <inheritdoc />
        public override TaskClientStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskClientStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskClientStatus));
        }
    }
}


/// <summary>Whether the shell runs inside a managed PTY session or as an independent background process.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskShellInfoAttachmentMode : IEquatable<TaskShellInfoAttachmentMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskShellInfoAttachmentMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskShellInfoAttachmentMode"/>.</param>
    [JsonConstructor]
    public TaskShellInfoAttachmentMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskShellInfoAttachmentMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The shell runs in a managed PTY session.</summary>
    public static TaskShellInfoAttachmentMode Attached { get; } = new("attached");

    /// <summary>The shell runs as an independent background process.</summary>
    public static TaskShellInfoAttachmentMode Detached { get; } = new("detached");

    /// <summary>Returns a value indicating whether two <see cref="TaskShellInfoAttachmentMode"/> instances are equivalent.</summary>
    public static bool operator ==(TaskShellInfoAttachmentMode left, TaskShellInfoAttachmentMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskShellInfoAttachmentMode"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskShellInfoAttachmentMode left, TaskShellInfoAttachmentMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskShellInfoAttachmentMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskShellInfoAttachmentMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskShellInfoAttachmentMode}"/> for serializing <see cref="TaskShellInfoAttachmentMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskShellInfoAttachmentMode>
    {
        /// <inheritdoc />
        public override TaskShellInfoAttachmentMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskShellInfoAttachmentMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskShellInfoAttachmentMode));
        }
    }
}


/// <summary>Discriminator for a client-owned task.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskClientType : IEquatable<TaskClientType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskClientType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskClientType"/>.</param>
    [JsonConstructor]
    public TaskClientType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskClientType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Gets the <c>client</c> value.</summary>
    public static TaskClientType Client { get; } = new("client");

    /// <summary>Returns a value indicating whether two <see cref="TaskClientType"/> instances are equivalent.</summary>
    public static bool operator ==(TaskClientType left, TaskClientType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskClientType"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskClientType left, TaskClientType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskClientType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskClientType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskClientType}"/> for serializing <see cref="TaskClientType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskClientType>
    {
        /// <inheritdoc />
        public override TaskClientType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskClientType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskClientType));
        }
    }
}


/// <summary>Active status a client owner may publish with a progress update.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct TaskClientActiveStatus : IEquatable<TaskClientActiveStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="TaskClientActiveStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="TaskClientActiveStatus"/>.</param>
    [JsonConstructor]
    public TaskClientActiveStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="TaskClientActiveStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The external owner is actively working.</summary>
    public static TaskClientActiveStatus Running { get; } = new("running");

    /// <summary>The external owner is connected but waiting.</summary>
    public static TaskClientActiveStatus Idle { get; } = new("idle");

    /// <summary>Returns a value indicating whether two <see cref="TaskClientActiveStatus"/> instances are equivalent.</summary>
    public static bool operator ==(TaskClientActiveStatus left, TaskClientActiveStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="TaskClientActiveStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(TaskClientActiveStatus left, TaskClientActiveStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is TaskClientActiveStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(TaskClientActiveStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{TaskClientActiveStatus}"/> for serializing <see cref="TaskClientActiveStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<TaskClientActiveStatus>
    {
        /// <inheritdoc />
        public override TaskClientActiveStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, TaskClientActiveStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(TaskClientActiveStatus));
        }
    }
}


/// <summary>Consumer allowed to call an MCP tool.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpToolUiVisibility : IEquatable<McpToolUiVisibility>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpToolUiVisibility"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpToolUiVisibility"/>.</param>
    [JsonConstructor]
    public McpToolUiVisibility(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpToolUiVisibility"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The model may call the tool.</summary>
    public static McpToolUiVisibility Model { get; } = new("model");

    /// <summary>An MCP App view may call the tool.</summary>
    public static McpToolUiVisibility App { get; } = new("app");

    /// <summary>Returns a value indicating whether two <see cref="McpToolUiVisibility"/> instances are equivalent.</summary>
    public static bool operator ==(McpToolUiVisibility left, McpToolUiVisibility right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpToolUiVisibility"/> instances are not equivalent.</summary>
    public static bool operator !=(McpToolUiVisibility left, McpToolUiVisibility right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpToolUiVisibility other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpToolUiVisibility other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpToolUiVisibility}"/> for serializing <see cref="McpToolUiVisibility"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpToolUiVisibility>
    {
        /// <inheritdoc />
        public override McpToolUiVisibility Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpToolUiVisibility value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpToolUiVisibility));
        }
    }
}


/// <summary>Outcome of the sampling inference. 'success' produced a response; 'failure' encountered an error (including agent-side rejection by content filter or criteria); 'cancelled' the caller cancelled this execution via cancelSamplingExecution.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpSamplingExecutionAction : IEquatable<McpSamplingExecutionAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpSamplingExecutionAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpSamplingExecutionAction"/>.</param>
    [JsonConstructor]
    public McpSamplingExecutionAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpSamplingExecutionAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The sampling inference completed and produced a result.</summary>
    public static McpSamplingExecutionAction Success { get; } = new("success");

    /// <summary>The sampling inference failed or was rejected.</summary>
    public static McpSamplingExecutionAction Failure { get; } = new("failure");

    /// <summary>The sampling inference was cancelled before completion.</summary>
    public static McpSamplingExecutionAction Cancelled { get; } = new("cancelled");

    /// <summary>Returns a value indicating whether two <see cref="McpSamplingExecutionAction"/> instances are equivalent.</summary>
    public static bool operator ==(McpSamplingExecutionAction left, McpSamplingExecutionAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpSamplingExecutionAction"/> instances are not equivalent.</summary>
    public static bool operator !=(McpSamplingExecutionAction left, McpSamplingExecutionAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpSamplingExecutionAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpSamplingExecutionAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpSamplingExecutionAction}"/> for serializing <see cref="McpSamplingExecutionAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpSamplingExecutionAction>
    {
        /// <inheritdoc />
        public override McpSamplingExecutionAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpSamplingExecutionAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpSamplingExecutionAction));
        }
    }
}


/// <summary>How environment-variable values supplied to MCP servers are resolved. "direct" passes literal string values; "indirect" treats values as references (e.g. names of environment variables on the host) that the runtime resolves before launch. Defaults to the runtime's startup mode; clients that intentionally launch MCP servers with literal values (e.g. CLI prompt mode and ACP) set this to "direct".</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpSetEnvValueModeDetails : IEquatable<McpSetEnvValueModeDetails>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpSetEnvValueModeDetails"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpSetEnvValueModeDetails"/>.</param>
    [JsonConstructor]
    public McpSetEnvValueModeDetails(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpSetEnvValueModeDetails"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Treat MCP server environment values as literal strings.</summary>
    public static McpSetEnvValueModeDetails Direct { get; } = new("direct");

    /// <summary>Treat MCP server environment values as host-side references to resolve before launch.</summary>
    public static McpSetEnvValueModeDetails Indirect { get; } = new("indirect");

    /// <summary>Returns a value indicating whether two <see cref="McpSetEnvValueModeDetails"/> instances are equivalent.</summary>
    public static bool operator ==(McpSetEnvValueModeDetails left, McpSetEnvValueModeDetails right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpSetEnvValueModeDetails"/> instances are not equivalent.</summary>
    public static bool operator !=(McpSetEnvValueModeDetails left, McpSetEnvValueModeDetails right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpSetEnvValueModeDetails other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpSetEnvValueModeDetails other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpSetEnvValueModeDetails}"/> for serializing <see cref="McpSetEnvValueModeDetails"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpSetEnvValueModeDetails>
    {
        /// <inheritdoc />
        public override McpSetEnvValueModeDetails Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpSetEnvValueModeDetails value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpSetEnvValueModeDetails));
        }
    }
}


/// <summary>OAuth grant type override for this login.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpOauthLoginGrantType : IEquatable<McpOauthLoginGrantType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpOauthLoginGrantType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpOauthLoginGrantType"/>.</param>
    [JsonConstructor]
    public McpOauthLoginGrantType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpOauthLoginGrantType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Interactive browser-based OAuth flow using an authorization code, typically with PKCE.</summary>
    public static McpOauthLoginGrantType AuthorizationCode { get; } = new("authorization_code");

    /// <summary>Headless OAuth flow where a confidential client authenticates directly with a client secret.</summary>
    public static McpOauthLoginGrantType ClientCredentials { get; } = new("client_credentials");

    /// <summary>Returns a value indicating whether two <see cref="McpOauthLoginGrantType"/> instances are equivalent.</summary>
    public static bool operator ==(McpOauthLoginGrantType left, McpOauthLoginGrantType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpOauthLoginGrantType"/> instances are not equivalent.</summary>
    public static bool operator !=(McpOauthLoginGrantType left, McpOauthLoginGrantType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpOauthLoginGrantType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpOauthLoginGrantType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpOauthLoginGrantType}"/> for serializing <see cref="McpOauthLoginGrantType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpOauthLoginGrantType>
    {
        /// <inheritdoc />
        public override McpOauthLoginGrantType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpOauthLoginGrantType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpOauthLoginGrantType));
        }
    }
}


/// <summary>Why a passive MCP OAuth probe determined authentication is needed.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpOauthProbeNeedsAuthReason : IEquatable<McpOauthProbeNeedsAuthReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpOauthProbeNeedsAuthReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpOauthProbeNeedsAuthReason"/>.</param>
    [JsonConstructor]
    public McpOauthProbeNeedsAuthReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpOauthProbeNeedsAuthReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>No token was sent and the server requires authentication.</summary>
    public static McpOauthProbeNeedsAuthReason Initial { get; } = new("initial");

    /// <summary>A cached token was sent and rejected.</summary>
    public static McpOauthProbeNeedsAuthReason Refresh { get; } = new("refresh");

    /// <summary>The server returned a 403 insufficient_scope challenge, indicating additional scopes or audience are needed.</summary>
    public static McpOauthProbeNeedsAuthReason Upscope { get; } = new("upscope");

    /// <summary>Returns a value indicating whether two <see cref="McpOauthProbeNeedsAuthReason"/> instances are equivalent.</summary>
    public static bool operator ==(McpOauthProbeNeedsAuthReason left, McpOauthProbeNeedsAuthReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpOauthProbeNeedsAuthReason"/> instances are not equivalent.</summary>
    public static bool operator !=(McpOauthProbeNeedsAuthReason left, McpOauthProbeNeedsAuthReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpOauthProbeNeedsAuthReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpOauthProbeNeedsAuthReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpOauthProbeNeedsAuthReason}"/> for serializing <see cref="McpOauthProbeNeedsAuthReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpOauthProbeNeedsAuthReason>
    {
        /// <inheritdoc />
        public override McpOauthProbeNeedsAuthReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpOauthProbeNeedsAuthReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpOauthProbeNeedsAuthReason));
        }
    }
}


/// <summary>Allowed values for the `McpAppsSetHostContextDetailsAvailableDisplayMode` enumeration.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsSetHostContextDetailsAvailableDisplayMode : IEquatable<McpAppsSetHostContextDetailsAvailableDisplayMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsSetHostContextDetailsAvailableDisplayMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsSetHostContextDetailsAvailableDisplayMode"/>.</param>
    [JsonConstructor]
    public McpAppsSetHostContextDetailsAvailableDisplayMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsSetHostContextDetailsAvailableDisplayMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Rendered inline within the host conversation surface.</summary>
    public static McpAppsSetHostContextDetailsAvailableDisplayMode Inline { get; } = new("inline");

    /// <summary>Rendered as a fullscreen overlay.</summary>
    public static McpAppsSetHostContextDetailsAvailableDisplayMode Fullscreen { get; } = new("fullscreen");

    /// <summary>Rendered as a picture-in-picture floating panel.</summary>
    public static McpAppsSetHostContextDetailsAvailableDisplayMode Pip { get; } = new("pip");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsAvailableDisplayMode"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsSetHostContextDetailsAvailableDisplayMode left, McpAppsSetHostContextDetailsAvailableDisplayMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsAvailableDisplayMode"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsSetHostContextDetailsAvailableDisplayMode left, McpAppsSetHostContextDetailsAvailableDisplayMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsSetHostContextDetailsAvailableDisplayMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsSetHostContextDetailsAvailableDisplayMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsSetHostContextDetailsAvailableDisplayMode}"/> for serializing <see cref="McpAppsSetHostContextDetailsAvailableDisplayMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsSetHostContextDetailsAvailableDisplayMode>
    {
        /// <inheritdoc />
        public override McpAppsSetHostContextDetailsAvailableDisplayMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsSetHostContextDetailsAvailableDisplayMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsSetHostContextDetailsAvailableDisplayMode));
        }
    }
}


/// <summary>Current display mode (SEP-1865).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsSetHostContextDetailsDisplayMode : IEquatable<McpAppsSetHostContextDetailsDisplayMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsSetHostContextDetailsDisplayMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsSetHostContextDetailsDisplayMode"/>.</param>
    [JsonConstructor]
    public McpAppsSetHostContextDetailsDisplayMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsSetHostContextDetailsDisplayMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Rendered inline within the host conversation surface.</summary>
    public static McpAppsSetHostContextDetailsDisplayMode Inline { get; } = new("inline");

    /// <summary>Rendered as a fullscreen overlay.</summary>
    public static McpAppsSetHostContextDetailsDisplayMode Fullscreen { get; } = new("fullscreen");

    /// <summary>Rendered as a picture-in-picture floating panel.</summary>
    public static McpAppsSetHostContextDetailsDisplayMode Pip { get; } = new("pip");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsDisplayMode"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsSetHostContextDetailsDisplayMode left, McpAppsSetHostContextDetailsDisplayMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsDisplayMode"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsSetHostContextDetailsDisplayMode left, McpAppsSetHostContextDetailsDisplayMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsSetHostContextDetailsDisplayMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsSetHostContextDetailsDisplayMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsSetHostContextDetailsDisplayMode}"/> for serializing <see cref="McpAppsSetHostContextDetailsDisplayMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsSetHostContextDetailsDisplayMode>
    {
        /// <inheritdoc />
        public override McpAppsSetHostContextDetailsDisplayMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsSetHostContextDetailsDisplayMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsSetHostContextDetailsDisplayMode));
        }
    }
}


/// <summary>Platform type for responsive design.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsSetHostContextDetailsPlatform : IEquatable<McpAppsSetHostContextDetailsPlatform>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsSetHostContextDetailsPlatform"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsSetHostContextDetailsPlatform"/>.</param>
    [JsonConstructor]
    public McpAppsSetHostContextDetailsPlatform(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsSetHostContextDetailsPlatform"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Host runs in a web browser.</summary>
    public static McpAppsSetHostContextDetailsPlatform Web { get; } = new("web");

    /// <summary>Host runs as a desktop application.</summary>
    public static McpAppsSetHostContextDetailsPlatform Desktop { get; } = new("desktop");

    /// <summary>Host runs on a mobile device.</summary>
    public static McpAppsSetHostContextDetailsPlatform Mobile { get; } = new("mobile");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsPlatform"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsSetHostContextDetailsPlatform left, McpAppsSetHostContextDetailsPlatform right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsPlatform"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsSetHostContextDetailsPlatform left, McpAppsSetHostContextDetailsPlatform right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsSetHostContextDetailsPlatform other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsSetHostContextDetailsPlatform other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsSetHostContextDetailsPlatform}"/> for serializing <see cref="McpAppsSetHostContextDetailsPlatform"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsSetHostContextDetailsPlatform>
    {
        /// <inheritdoc />
        public override McpAppsSetHostContextDetailsPlatform Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsSetHostContextDetailsPlatform value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsSetHostContextDetailsPlatform));
        }
    }
}


/// <summary>UI theme preference per SEP-1865.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsSetHostContextDetailsTheme : IEquatable<McpAppsSetHostContextDetailsTheme>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsSetHostContextDetailsTheme"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsSetHostContextDetailsTheme"/>.</param>
    [JsonConstructor]
    public McpAppsSetHostContextDetailsTheme(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsSetHostContextDetailsTheme"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Light UI theme.</summary>
    public static McpAppsSetHostContextDetailsTheme Light { get; } = new("light");

    /// <summary>Dark UI theme.</summary>
    public static McpAppsSetHostContextDetailsTheme Dark { get; } = new("dark");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsTheme"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsSetHostContextDetailsTheme left, McpAppsSetHostContextDetailsTheme right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsSetHostContextDetailsTheme"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsSetHostContextDetailsTheme left, McpAppsSetHostContextDetailsTheme right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsSetHostContextDetailsTheme other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsSetHostContextDetailsTheme other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsSetHostContextDetailsTheme}"/> for serializing <see cref="McpAppsSetHostContextDetailsTheme"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsSetHostContextDetailsTheme>
    {
        /// <inheritdoc />
        public override McpAppsSetHostContextDetailsTheme Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsSetHostContextDetailsTheme value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsSetHostContextDetailsTheme));
        }
    }
}


/// <summary>Allowed values for the `McpAppsHostContextDetailsAvailableDisplayMode` enumeration.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsHostContextDetailsAvailableDisplayMode : IEquatable<McpAppsHostContextDetailsAvailableDisplayMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsHostContextDetailsAvailableDisplayMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsHostContextDetailsAvailableDisplayMode"/>.</param>
    [JsonConstructor]
    public McpAppsHostContextDetailsAvailableDisplayMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsHostContextDetailsAvailableDisplayMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Rendered inline within the host conversation surface.</summary>
    public static McpAppsHostContextDetailsAvailableDisplayMode Inline { get; } = new("inline");

    /// <summary>Rendered as a fullscreen overlay.</summary>
    public static McpAppsHostContextDetailsAvailableDisplayMode Fullscreen { get; } = new("fullscreen");

    /// <summary>Rendered as a picture-in-picture floating panel.</summary>
    public static McpAppsHostContextDetailsAvailableDisplayMode Pip { get; } = new("pip");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsAvailableDisplayMode"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsHostContextDetailsAvailableDisplayMode left, McpAppsHostContextDetailsAvailableDisplayMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsAvailableDisplayMode"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsHostContextDetailsAvailableDisplayMode left, McpAppsHostContextDetailsAvailableDisplayMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsHostContextDetailsAvailableDisplayMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsHostContextDetailsAvailableDisplayMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsHostContextDetailsAvailableDisplayMode}"/> for serializing <see cref="McpAppsHostContextDetailsAvailableDisplayMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsHostContextDetailsAvailableDisplayMode>
    {
        /// <inheritdoc />
        public override McpAppsHostContextDetailsAvailableDisplayMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsHostContextDetailsAvailableDisplayMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsHostContextDetailsAvailableDisplayMode));
        }
    }
}


/// <summary>Current display mode (SEP-1865).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsHostContextDetailsDisplayMode : IEquatable<McpAppsHostContextDetailsDisplayMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsHostContextDetailsDisplayMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsHostContextDetailsDisplayMode"/>.</param>
    [JsonConstructor]
    public McpAppsHostContextDetailsDisplayMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsHostContextDetailsDisplayMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Rendered inline within the host conversation surface.</summary>
    public static McpAppsHostContextDetailsDisplayMode Inline { get; } = new("inline");

    /// <summary>Rendered as a fullscreen overlay.</summary>
    public static McpAppsHostContextDetailsDisplayMode Fullscreen { get; } = new("fullscreen");

    /// <summary>Rendered as a picture-in-picture floating panel.</summary>
    public static McpAppsHostContextDetailsDisplayMode Pip { get; } = new("pip");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsDisplayMode"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsHostContextDetailsDisplayMode left, McpAppsHostContextDetailsDisplayMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsDisplayMode"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsHostContextDetailsDisplayMode left, McpAppsHostContextDetailsDisplayMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsHostContextDetailsDisplayMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsHostContextDetailsDisplayMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsHostContextDetailsDisplayMode}"/> for serializing <see cref="McpAppsHostContextDetailsDisplayMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsHostContextDetailsDisplayMode>
    {
        /// <inheritdoc />
        public override McpAppsHostContextDetailsDisplayMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsHostContextDetailsDisplayMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsHostContextDetailsDisplayMode));
        }
    }
}


/// <summary>Platform type for responsive design.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsHostContextDetailsPlatform : IEquatable<McpAppsHostContextDetailsPlatform>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsHostContextDetailsPlatform"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsHostContextDetailsPlatform"/>.</param>
    [JsonConstructor]
    public McpAppsHostContextDetailsPlatform(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsHostContextDetailsPlatform"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Host runs in a web browser.</summary>
    public static McpAppsHostContextDetailsPlatform Web { get; } = new("web");

    /// <summary>Host runs as a desktop application.</summary>
    public static McpAppsHostContextDetailsPlatform Desktop { get; } = new("desktop");

    /// <summary>Host runs on a mobile device.</summary>
    public static McpAppsHostContextDetailsPlatform Mobile { get; } = new("mobile");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsPlatform"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsHostContextDetailsPlatform left, McpAppsHostContextDetailsPlatform right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsPlatform"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsHostContextDetailsPlatform left, McpAppsHostContextDetailsPlatform right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsHostContextDetailsPlatform other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsHostContextDetailsPlatform other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsHostContextDetailsPlatform}"/> for serializing <see cref="McpAppsHostContextDetailsPlatform"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsHostContextDetailsPlatform>
    {
        /// <inheritdoc />
        public override McpAppsHostContextDetailsPlatform Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsHostContextDetailsPlatform value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsHostContextDetailsPlatform));
        }
    }
}


/// <summary>UI theme preference per SEP-1865.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpAppsHostContextDetailsTheme : IEquatable<McpAppsHostContextDetailsTheme>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpAppsHostContextDetailsTheme"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpAppsHostContextDetailsTheme"/>.</param>
    [JsonConstructor]
    public McpAppsHostContextDetailsTheme(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpAppsHostContextDetailsTheme"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Light UI theme.</summary>
    public static McpAppsHostContextDetailsTheme Light { get; } = new("light");

    /// <summary>Dark UI theme.</summary>
    public static McpAppsHostContextDetailsTheme Dark { get; } = new("dark");

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsTheme"/> instances are equivalent.</summary>
    public static bool operator ==(McpAppsHostContextDetailsTheme left, McpAppsHostContextDetailsTheme right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpAppsHostContextDetailsTheme"/> instances are not equivalent.</summary>
    public static bool operator !=(McpAppsHostContextDetailsTheme left, McpAppsHostContextDetailsTheme right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpAppsHostContextDetailsTheme other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpAppsHostContextDetailsTheme other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpAppsHostContextDetailsTheme}"/> for serializing <see cref="McpAppsHostContextDetailsTheme"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpAppsHostContextDetailsTheme>
    {
        /// <inheritdoc />
        public override McpAppsHostContextDetailsTheme Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpAppsHostContextDetailsTheme value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpAppsHostContextDetailsTheme));
        }
    }
}


/// <summary>Transport to be used for provider requests.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ProviderEndpointTransport : IEquatable<ProviderEndpointTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ProviderEndpointTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ProviderEndpointTransport"/>.</param>
    [JsonConstructor]
    public ProviderEndpointTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ProviderEndpointTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>HTTP request/streaming transport.</summary>
    public static ProviderEndpointTransport Http { get; } = new("http");

    /// <summary>WebSocket transport.</summary>
    public static ProviderEndpointTransport Websockets { get; } = new("websockets");

    /// <summary>Returns a value indicating whether two <see cref="ProviderEndpointTransport"/> instances are equivalent.</summary>
    public static bool operator ==(ProviderEndpointTransport left, ProviderEndpointTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ProviderEndpointTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(ProviderEndpointTransport left, ProviderEndpointTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ProviderEndpointTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ProviderEndpointTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ProviderEndpointTransport}"/> for serializing <see cref="ProviderEndpointTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ProviderEndpointTransport>
    {
        /// <inheritdoc />
        public override ProviderEndpointTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ProviderEndpointTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ProviderEndpointTransport));
        }
    }
}


/// <summary>Provider family. Matches the `type` field of a BYOK provider config.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ProviderEndpointType : IEquatable<ProviderEndpointType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ProviderEndpointType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ProviderEndpointType"/>.</param>
    [JsonConstructor]
    public ProviderEndpointType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ProviderEndpointType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>OpenAI-compatible endpoint (use the OpenAI client library).</summary>
    public static ProviderEndpointType Openai { get; } = new("openai");

    /// <summary>Azure OpenAI endpoint (use the OpenAI client library with the Azure base URL).</summary>
    public static ProviderEndpointType Azure { get; } = new("azure");

    /// <summary>Anthropic endpoint (use the Anthropic client library).</summary>
    public static ProviderEndpointType Anthropic { get; } = new("anthropic");

    /// <summary>Returns a value indicating whether two <see cref="ProviderEndpointType"/> instances are equivalent.</summary>
    public static bool operator ==(ProviderEndpointType left, ProviderEndpointType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ProviderEndpointType"/> instances are not equivalent.</summary>
    public static bool operator !=(ProviderEndpointType left, ProviderEndpointType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ProviderEndpointType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ProviderEndpointType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ProviderEndpointType}"/> for serializing <see cref="ProviderEndpointType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ProviderEndpointType>
    {
        /// <inheritdoc />
        public override ProviderEndpointType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ProviderEndpointType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ProviderEndpointType));
        }
    }
}


/// <summary>Wire API to be used, when required for the provider type.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ProviderEndpointWireApi : IEquatable<ProviderEndpointWireApi>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ProviderEndpointWireApi"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ProviderEndpointWireApi"/>.</param>
    [JsonConstructor]
    public ProviderEndpointWireApi(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ProviderEndpointWireApi"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Classic chat-completions request shape.</summary>
    public static ProviderEndpointWireApi Completions { get; } = new("completions");

    /// <summary>Newer responses request shape.</summary>
    public static ProviderEndpointWireApi Responses { get; } = new("responses");

    /// <summary>Returns a value indicating whether two <see cref="ProviderEndpointWireApi"/> instances are equivalent.</summary>
    public static bool operator ==(ProviderEndpointWireApi left, ProviderEndpointWireApi right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ProviderEndpointWireApi"/> instances are not equivalent.</summary>
    public static bool operator !=(ProviderEndpointWireApi left, ProviderEndpointWireApi right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ProviderEndpointWireApi other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ProviderEndpointWireApi other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ProviderEndpointWireApi}"/> for serializing <see cref="ProviderEndpointWireApi"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ProviderEndpointWireApi>
    {
        /// <inheritdoc />
        public override ProviderEndpointWireApi Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ProviderEndpointWireApi value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ProviderEndpointWireApi));
        }
    }
}


/// <summary>Provider transport. Defaults to "http".</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ProviderConfigTransport : IEquatable<ProviderConfigTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ProviderConfigTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ProviderConfigTransport"/>.</param>
    [JsonConstructor]
    public ProviderConfigTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ProviderConfigTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>HTTP request/streaming transport.</summary>
    public static ProviderConfigTransport Http { get; } = new("http");

    /// <summary>WebSocket transport.</summary>
    public static ProviderConfigTransport Websockets { get; } = new("websockets");

    /// <summary>Returns a value indicating whether two <see cref="ProviderConfigTransport"/> instances are equivalent.</summary>
    public static bool operator ==(ProviderConfigTransport left, ProviderConfigTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ProviderConfigTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(ProviderConfigTransport left, ProviderConfigTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ProviderConfigTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ProviderConfigTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ProviderConfigTransport}"/> for serializing <see cref="ProviderConfigTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ProviderConfigTransport>
    {
        /// <inheritdoc />
        public override ProviderConfigTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ProviderConfigTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ProviderConfigTransport));
        }
    }
}


/// <summary>Provider type. Defaults to "openai" for generic OpenAI-compatible APIs.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ProviderConfigType : IEquatable<ProviderConfigType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ProviderConfigType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ProviderConfigType"/>.</param>
    [JsonConstructor]
    public ProviderConfigType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ProviderConfigType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Generic OpenAI-compatible API.</summary>
    public static ProviderConfigType Openai { get; } = new("openai");

    /// <summary>Azure OpenAI Service endpoint.</summary>
    public static ProviderConfigType Azure { get; } = new("azure");

    /// <summary>Anthropic API endpoint.</summary>
    public static ProviderConfigType Anthropic { get; } = new("anthropic");

    /// <summary>Returns a value indicating whether two <see cref="ProviderConfigType"/> instances are equivalent.</summary>
    public static bool operator ==(ProviderConfigType left, ProviderConfigType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ProviderConfigType"/> instances are not equivalent.</summary>
    public static bool operator !=(ProviderConfigType left, ProviderConfigType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ProviderConfigType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ProviderConfigType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ProviderConfigType}"/> for serializing <see cref="ProviderConfigType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ProviderConfigType>
    {
        /// <inheritdoc />
        public override ProviderConfigType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ProviderConfigType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ProviderConfigType));
        }
    }
}


/// <summary>Wire API format (openai/azure only). Defaults to "completions".</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ProviderConfigWireApi : IEquatable<ProviderConfigWireApi>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ProviderConfigWireApi"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ProviderConfigWireApi"/>.</param>
    [JsonConstructor]
    public ProviderConfigWireApi(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ProviderConfigWireApi"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>OpenAI Chat Completions wire format.</summary>
    public static ProviderConfigWireApi Completions { get; } = new("completions");

    /// <summary>OpenAI Responses API wire format.</summary>
    public static ProviderConfigWireApi Responses { get; } = new("responses");

    /// <summary>Returns a value indicating whether two <see cref="ProviderConfigWireApi"/> instances are equivalent.</summary>
    public static bool operator ==(ProviderConfigWireApi left, ProviderConfigWireApi right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ProviderConfigWireApi"/> instances are not equivalent.</summary>
    public static bool operator !=(ProviderConfigWireApi left, ProviderConfigWireApi right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ProviderConfigWireApi other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ProviderConfigWireApi other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ProviderConfigWireApi}"/> for serializing <see cref="ProviderConfigWireApi"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ProviderConfigWireApi>
    {
        /// <inheritdoc />
        public override ProviderConfigWireApi Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ProviderConfigWireApi value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ProviderConfigWireApi));
        }
    }
}


/// <summary>Allowed values for the `OptionsUpdateAdditionalContentExclusionPolicyScope` enumeration.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct OptionsUpdateAdditionalContentExclusionPolicyScope : IEquatable<OptionsUpdateAdditionalContentExclusionPolicyScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="OptionsUpdateAdditionalContentExclusionPolicyScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="OptionsUpdateAdditionalContentExclusionPolicyScope"/>.</param>
    [JsonConstructor]
    public OptionsUpdateAdditionalContentExclusionPolicyScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="OptionsUpdateAdditionalContentExclusionPolicyScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The content exclusion policy applies to the current repository.</summary>
    public static OptionsUpdateAdditionalContentExclusionPolicyScope Repo { get; } = new("repo");

    /// <summary>The content exclusion policy applies across all repositories.</summary>
    public static OptionsUpdateAdditionalContentExclusionPolicyScope All { get; } = new("all");

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateAdditionalContentExclusionPolicyScope"/> instances are equivalent.</summary>
    public static bool operator ==(OptionsUpdateAdditionalContentExclusionPolicyScope left, OptionsUpdateAdditionalContentExclusionPolicyScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateAdditionalContentExclusionPolicyScope"/> instances are not equivalent.</summary>
    public static bool operator !=(OptionsUpdateAdditionalContentExclusionPolicyScope left, OptionsUpdateAdditionalContentExclusionPolicyScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is OptionsUpdateAdditionalContentExclusionPolicyScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(OptionsUpdateAdditionalContentExclusionPolicyScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{OptionsUpdateAdditionalContentExclusionPolicyScope}"/> for serializing <see cref="OptionsUpdateAdditionalContentExclusionPolicyScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<OptionsUpdateAdditionalContentExclusionPolicyScope>
    {
        /// <inheritdoc />
        public override OptionsUpdateAdditionalContentExclusionPolicyScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, OptionsUpdateAdditionalContentExclusionPolicyScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(OptionsUpdateAdditionalContentExclusionPolicyScope));
        }
    }
}


/// <summary>Context tier for models with tiered pricing. The session uses this to derive effective `modelCapabilitiesOverrides` so compaction, truncation, token display, and request limits honor the selected tier.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct OptionsUpdateContextTier : IEquatable<OptionsUpdateContextTier>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="OptionsUpdateContextTier"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="OptionsUpdateContextTier"/>.</param>
    [JsonConstructor]
    public OptionsUpdateContextTier(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="OptionsUpdateContextTier"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Use the model's default context tier and its standard token limits / pricing.</summary>
    public static OptionsUpdateContextTier Default { get; } = new("default");

    /// <summary>Use the model's long-context tier (when available) so larger inputs are accepted and tier-specific pricing applies.</summary>
    public static OptionsUpdateContextTier LongContext { get; } = new("long_context");

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateContextTier"/> instances are equivalent.</summary>
    public static bool operator ==(OptionsUpdateContextTier left, OptionsUpdateContextTier right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateContextTier"/> instances are not equivalent.</summary>
    public static bool operator !=(OptionsUpdateContextTier left, OptionsUpdateContextTier right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is OptionsUpdateContextTier other && Equals(other);

    /// <inheritdoc />
    public bool Equals(OptionsUpdateContextTier other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{OptionsUpdateContextTier}"/> for serializing <see cref="OptionsUpdateContextTier"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<OptionsUpdateContextTier>
    {
        /// <inheritdoc />
        public override OptionsUpdateContextTier Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, OptionsUpdateContextTier value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(OptionsUpdateContextTier));
        }
    }
}


/// <summary>How env values are passed to MCP servers (`direct` inlines literal values; `indirect` resolves at launch).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct OptionsUpdateEnvValueMode : IEquatable<OptionsUpdateEnvValueMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="OptionsUpdateEnvValueMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="OptionsUpdateEnvValueMode"/>.</param>
    [JsonConstructor]
    public OptionsUpdateEnvValueMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="OptionsUpdateEnvValueMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Pass MCP server environment values as literal strings.</summary>
    public static OptionsUpdateEnvValueMode Direct { get; } = new("direct");

    /// <summary>Resolve MCP server environment values from host-side references.</summary>
    public static OptionsUpdateEnvValueMode Indirect { get; } = new("indirect");

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateEnvValueMode"/> instances are equivalent.</summary>
    public static bool operator ==(OptionsUpdateEnvValueMode left, OptionsUpdateEnvValueMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateEnvValueMode"/> instances are not equivalent.</summary>
    public static bool operator !=(OptionsUpdateEnvValueMode left, OptionsUpdateEnvValueMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is OptionsUpdateEnvValueMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(OptionsUpdateEnvValueMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{OptionsUpdateEnvValueMode}"/> for serializing <see cref="OptionsUpdateEnvValueMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<OptionsUpdateEnvValueMode>
    {
        /// <inheritdoc />
        public override OptionsUpdateEnvValueMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, OptionsUpdateEnvValueMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(OptionsUpdateEnvValueMode));
        }
    }
}


/// <summary>Reasoning summary mode for supported model clients.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct OptionsUpdateReasoningSummary : IEquatable<OptionsUpdateReasoningSummary>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="OptionsUpdateReasoningSummary"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="OptionsUpdateReasoningSummary"/>.</param>
    [JsonConstructor]
    public OptionsUpdateReasoningSummary(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="OptionsUpdateReasoningSummary"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Do not request reasoning summaries from the model.</summary>
    public static OptionsUpdateReasoningSummary None { get; } = new("none");

    /// <summary>Request a concise summary of model reasoning.</summary>
    public static OptionsUpdateReasoningSummary Concise { get; } = new("concise");

    /// <summary>Request a detailed summary of model reasoning.</summary>
    public static OptionsUpdateReasoningSummary Detailed { get; } = new("detailed");

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateReasoningSummary"/> instances are equivalent.</summary>
    public static bool operator ==(OptionsUpdateReasoningSummary left, OptionsUpdateReasoningSummary right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateReasoningSummary"/> instances are not equivalent.</summary>
    public static bool operator !=(OptionsUpdateReasoningSummary left, OptionsUpdateReasoningSummary right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is OptionsUpdateReasoningSummary other && Equals(other);

    /// <inheritdoc />
    public bool Equals(OptionsUpdateReasoningSummary other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{OptionsUpdateReasoningSummary}"/> for serializing <see cref="OptionsUpdateReasoningSummary"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<OptionsUpdateReasoningSummary>
    {
        /// <inheritdoc />
        public override OptionsUpdateReasoningSummary Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, OptionsUpdateReasoningSummary value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(OptionsUpdateReasoningSummary));
        }
    }
}


/// <summary>Origin of the sandbox choice supplied by an internal client.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SandboxConfigSource : IEquatable<SandboxConfigSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SandboxConfigSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SandboxConfigSource"/>.</param>
    [JsonConstructor]
    public SandboxConfigSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SandboxConfigSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The client applied the default because no sandbox preference was configured.</summary>
    public static SandboxConfigSource NeverConfigured { get; } = new("never_configured");

    /// <summary>The user's persisted settings enabled the sandbox.</summary>
    public static SandboxConfigSource UserEnabled { get; } = new("user_enabled");

    /// <summary>The user's persisted settings disabled the sandbox.</summary>
    public static SandboxConfigSource UserDisabled { get; } = new("user_disabled");

    /// <summary>A command-line flag selected the sandbox state for this session.</summary>
    public static SandboxConfigSource SessionFlag { get; } = new("session_flag");

    /// <summary>The user disabled the sandbox for the current session.</summary>
    public static SandboxConfigSource SessionDisabled { get; } = new("session_disabled");

    /// <summary>The client disabled the sandbox because the host cannot enforce it.</summary>
    public static SandboxConfigSource UnsupportedHost { get; } = new("unsupported_host");

    /// <summary>A repository policy selected the sandbox state.</summary>
    public static SandboxConfigSource RepositoryPolicy { get; } = new("repository_policy");

    /// <summary>Returns a value indicating whether two <see cref="SandboxConfigSource"/> instances are equivalent.</summary>
    public static bool operator ==(SandboxConfigSource left, SandboxConfigSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SandboxConfigSource"/> instances are not equivalent.</summary>
    public static bool operator !=(SandboxConfigSource left, SandboxConfigSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SandboxConfigSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SandboxConfigSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SandboxConfigSource}"/> for serializing <see cref="SandboxConfigSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SandboxConfigSource>
    {
        /// <inheritdoc />
        public override SandboxConfigSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SandboxConfigSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SandboxConfigSource));
        }
    }
}


/// <summary>Session capability enabled for this session.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionCapability : IEquatable<SessionCapability>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionCapability"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionCapability"/>.</param>
    [JsonConstructor]
    public SessionCapability(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionCapability"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>TUI-specific prompt hints such as keyboard shortcuts.</summary>
    public static SessionCapability TuiHints { get; } = new("tui-hints");

    /// <summary>Plan-mode handling and instructions.</summary>
    public static SessionCapability PlanMode { get; } = new("plan-mode");

    /// <summary>Memory tool and memories prompt section.</summary>
    public static SessionCapability Memory { get; } = new("memory");

    /// <summary>Copilot CLI documentation tool and prompt section.</summary>
    public static SessionCapability CliDocumentation { get; } = new("cli-documentation");

    /// <summary>Interactive ask_user tool support.</summary>
    public static SessionCapability AskUser { get; } = new("ask-user");

    /// <summary>Interactive CLI identity and behavior.</summary>
    public static SessionCapability InteractiveMode { get; } = new("interactive-mode");

    /// <summary>Automatic hidden system notifications.</summary>
    public static SessionCapability SystemNotifications { get; } = new("system-notifications");

    /// <summary>SDK elicitation support.</summary>
    public static SessionCapability Elicitation { get; } = new("elicitation");

    /// <summary>Cross-session history tools and session-store SQL prompt/tool metadata.</summary>
    public static SessionCapability SessionStore { get; } = new("session-store");

    /// <summary>MCP Apps UI passthrough.</summary>
    public static SessionCapability McpApps { get; } = new("mcp-apps");

    /// <summary>Host-provided canvas rendering support.</summary>
    public static SessionCapability CanvasRenderer { get; } = new("canvas-renderer");

    /// <summary>Returns a value indicating whether two <see cref="SessionCapability"/> instances are equivalent.</summary>
    public static bool operator ==(SessionCapability left, SessionCapability right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionCapability"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionCapability left, SessionCapability right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionCapability other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionCapability other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionCapability}"/> for serializing <see cref="SessionCapability"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionCapability>
    {
        /// <inheritdoc />
        public override SessionCapability Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionCapability value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionCapability));
        }
    }
}


/// <summary>Controls automatic non-interactive profile loading where supported. Explicit initScripts are unaffected.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ShellInitProfile : IEquatable<ShellInitProfile>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ShellInitProfile"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ShellInitProfile"/>.</param>
    [JsonConstructor]
    public ShellInitProfile(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ShellInitProfile"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Disable automatic non-interactive profile loading. Explicit initScripts still run.</summary>
    public static ShellInitProfile None { get; } = new("none");

    /// <summary>Allow automatic non-interactive profile loading when supported. Explicit initScripts still run.</summary>
    public static ShellInitProfile NonInteractive { get; } = new("non-interactive");

    /// <summary>Returns a value indicating whether two <see cref="ShellInitProfile"/> instances are equivalent.</summary>
    public static bool operator ==(ShellInitProfile left, ShellInitProfile right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ShellInitProfile"/> instances are not equivalent.</summary>
    public static bool operator !=(ShellInitProfile left, ShellInitProfile right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ShellInitProfile other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ShellInitProfile other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ShellInitProfile}"/> for serializing <see cref="ShellInitProfile"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ShellInitProfile>
    {
        /// <inheritdoc />
        public override ShellInitProfile Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ShellInitProfile value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ShellInitProfile));
        }
    }
}


/// <summary>Supported built-in shells for initialization scripts.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ShellInitScriptShell : IEquatable<ShellInitScriptShell>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ShellInitScriptShell"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ShellInitScriptShell"/>.</param>
    [JsonConstructor]
    public ShellInitScriptShell(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ShellInitScriptShell"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Source the script in the built-in Bash shell on macOS and Linux.</summary>
    public static ShellInitScriptShell Bash { get; } = new("bash");

    /// <summary>Source the script in the built-in PowerShell shell on Windows.</summary>
    public static ShellInitScriptShell Powershell { get; } = new("powershell");

    /// <summary>Returns a value indicating whether two <see cref="ShellInitScriptShell"/> instances are equivalent.</summary>
    public static bool operator ==(ShellInitScriptShell left, ShellInitScriptShell right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ShellInitScriptShell"/> instances are not equivalent.</summary>
    public static bool operator !=(ShellInitScriptShell left, ShellInitScriptShell right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ShellInitScriptShell other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ShellInitScriptShell other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ShellInitScriptShell}"/> for serializing <see cref="ShellInitScriptShell"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ShellInitScriptShell>
    {
        /// <inheritdoc />
        public override ShellInitScriptShell Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ShellInitScriptShell value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ShellInitScriptShell));
        }
    }
}


/// <summary>Controls how availableTools (allowlist) and excludedTools (denylist) combine when both are set.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct OptionsUpdateToolFilterPrecedence : IEquatable<OptionsUpdateToolFilterPrecedence>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="OptionsUpdateToolFilterPrecedence"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="OptionsUpdateToolFilterPrecedence"/>.</param>
    [JsonConstructor]
    public OptionsUpdateToolFilterPrecedence(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="OptionsUpdateToolFilterPrecedence"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>If availableTools is set, it is the only constraint that applies (excludedTools is ignored). Preserves CLI / pre-existing client behavior. Default.</summary>
    public static OptionsUpdateToolFilterPrecedence Available { get; } = new("available");

    /// <summary>A tool is enabled if and only if it matches the allowlist (or the allowlist is unset) AND it does not match the denylist. Makes 'all except X' expressible by combining the two lists.</summary>
    public static OptionsUpdateToolFilterPrecedence Excluded { get; } = new("excluded");

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateToolFilterPrecedence"/> instances are equivalent.</summary>
    public static bool operator ==(OptionsUpdateToolFilterPrecedence left, OptionsUpdateToolFilterPrecedence right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="OptionsUpdateToolFilterPrecedence"/> instances are not equivalent.</summary>
    public static bool operator !=(OptionsUpdateToolFilterPrecedence left, OptionsUpdateToolFilterPrecedence right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is OptionsUpdateToolFilterPrecedence other && Equals(other);

    /// <inheritdoc />
    public bool Equals(OptionsUpdateToolFilterPrecedence other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{OptionsUpdateToolFilterPrecedence}"/> for serializing <see cref="OptionsUpdateToolFilterPrecedence"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<OptionsUpdateToolFilterPrecedence>
    {
        /// <inheritdoc />
        public override OptionsUpdateToolFilterPrecedence Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, OptionsUpdateToolFilterPrecedence value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(OptionsUpdateToolFilterPrecedence));
        }
    }
}


/// <summary>Discovery source: project (.github/extensions/), user (~/.copilot/extensions/), plugin (installed plugin), or session (session-state/&lt;id&gt;/extensions/).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ExtensionSource : IEquatable<ExtensionSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ExtensionSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ExtensionSource"/>.</param>
    [JsonConstructor]
    public ExtensionSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ExtensionSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Extension discovered from the current project's .github/extensions directory.</summary>
    public static ExtensionSource Project { get; } = new("project");

    /// <summary>Extension discovered from the user's ~/.copilot/extensions directory.</summary>
    public static ExtensionSource User { get; } = new("user");

    /// <summary>Extension contributed by an installed plugin.</summary>
    public static ExtensionSource Plugin { get; } = new("plugin");

    /// <summary>Extension discovered from the current session's state directory (loaded only for this session).</summary>
    public static ExtensionSource Session { get; } = new("session");

    /// <summary>Returns a value indicating whether two <see cref="ExtensionSource"/> instances are equivalent.</summary>
    public static bool operator ==(ExtensionSource left, ExtensionSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ExtensionSource"/> instances are not equivalent.</summary>
    public static bool operator !=(ExtensionSource left, ExtensionSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ExtensionSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ExtensionSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ExtensionSource}"/> for serializing <see cref="ExtensionSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ExtensionSource>
    {
        /// <inheritdoc />
        public override ExtensionSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ExtensionSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ExtensionSource));
        }
    }
}


/// <summary>Current status: running, disabled, failed, or starting.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ExtensionStatus : IEquatable<ExtensionStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ExtensionStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ExtensionStatus"/>.</param>
    [JsonConstructor]
    public ExtensionStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ExtensionStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The extension process is running.</summary>
    public static ExtensionStatus Running { get; } = new("running");

    /// <summary>The extension is installed but disabled.</summary>
    public static ExtensionStatus Disabled { get; } = new("disabled");

    /// <summary>The extension failed to start or crashed.</summary>
    public static ExtensionStatus Failed { get; } = new("failed");

    /// <summary>The extension process is starting.</summary>
    public static ExtensionStatus Starting { get; } = new("starting");

    /// <summary>Returns a value indicating whether two <see cref="ExtensionStatus"/> instances are equivalent.</summary>
    public static bool operator ==(ExtensionStatus left, ExtensionStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ExtensionStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(ExtensionStatus left, ExtensionStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ExtensionStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ExtensionStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ExtensionStatus}"/> for serializing <see cref="ExtensionStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ExtensionStatus>
    {
        /// <inheritdoc />
        public override ExtensionStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ExtensionStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ExtensionStatus));
        }
    }
}


/// <summary>Type of GitHub reference.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PushAttachmentGitHubReferenceType : IEquatable<PushAttachmentGitHubReferenceType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PushAttachmentGitHubReferenceType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PushAttachmentGitHubReferenceType"/>.</param>
    [JsonConstructor]
    public PushAttachmentGitHubReferenceType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PushAttachmentGitHubReferenceType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>GitHub issue reference.</summary>
    public static PushAttachmentGitHubReferenceType Issue { get; } = new("issue");

    /// <summary>GitHub pull request reference.</summary>
    public static PushAttachmentGitHubReferenceType Pr { get; } = new("pr");

    /// <summary>GitHub discussion reference.</summary>
    public static PushAttachmentGitHubReferenceType Discussion { get; } = new("discussion");

    /// <summary>Returns a value indicating whether two <see cref="PushAttachmentGitHubReferenceType"/> instances are equivalent.</summary>
    public static bool operator ==(PushAttachmentGitHubReferenceType left, PushAttachmentGitHubReferenceType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PushAttachmentGitHubReferenceType"/> instances are not equivalent.</summary>
    public static bool operator !=(PushAttachmentGitHubReferenceType left, PushAttachmentGitHubReferenceType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PushAttachmentGitHubReferenceType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PushAttachmentGitHubReferenceType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PushAttachmentGitHubReferenceType}"/> for serializing <see cref="PushAttachmentGitHubReferenceType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PushAttachmentGitHubReferenceType>
    {
        /// <inheritdoc />
        public override PushAttachmentGitHubReferenceType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PushAttachmentGitHubReferenceType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PushAttachmentGitHubReferenceType));
        }
    }
}


/// <summary>Custom input-format kind.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct BuiltinToolFormatType : IEquatable<BuiltinToolFormatType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="BuiltinToolFormatType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="BuiltinToolFormatType"/>.</param>
    [JsonConstructor]
    public BuiltinToolFormatType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="BuiltinToolFormatType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The tool input is parsed with the supplied grammar.</summary>
    public static BuiltinToolFormatType Grammar { get; } = new("grammar");

    /// <summary>Returns a value indicating whether two <see cref="BuiltinToolFormatType"/> instances are equivalent.</summary>
    public static bool operator ==(BuiltinToolFormatType left, BuiltinToolFormatType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="BuiltinToolFormatType"/> instances are not equivalent.</summary>
    public static bool operator !=(BuiltinToolFormatType left, BuiltinToolFormatType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is BuiltinToolFormatType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(BuiltinToolFormatType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{BuiltinToolFormatType}"/> for serializing <see cref="BuiltinToolFormatType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<BuiltinToolFormatType>
    {
        /// <inheritdoc />
        public override BuiltinToolFormatType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, BuiltinToolFormatType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(BuiltinToolFormatType));
        }
    }
}


/// <summary>Root JSON Schema type for a built-in tool input.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct BuiltinToolInputSchemaType : IEquatable<BuiltinToolInputSchemaType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="BuiltinToolInputSchemaType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="BuiltinToolInputSchemaType"/>.</param>
    [JsonConstructor]
    public BuiltinToolInputSchemaType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="BuiltinToolInputSchemaType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The tool accepts a JSON object.</summary>
    public static BuiltinToolInputSchemaType Object { get; } = new("object");

    /// <summary>Returns a value indicating whether two <see cref="BuiltinToolInputSchemaType"/> instances are equivalent.</summary>
    public static bool operator ==(BuiltinToolInputSchemaType left, BuiltinToolInputSchemaType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="BuiltinToolInputSchemaType"/> instances are not equivalent.</summary>
    public static bool operator !=(BuiltinToolInputSchemaType left, BuiltinToolInputSchemaType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is BuiltinToolInputSchemaType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(BuiltinToolInputSchemaType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{BuiltinToolInputSchemaType}"/> for serializing <see cref="BuiltinToolInputSchemaType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<BuiltinToolInputSchemaType>
    {
        /// <inheritdoc />
        public override BuiltinToolInputSchemaType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, BuiltinToolInputSchemaType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(BuiltinToolInputSchemaType));
        }
    }
}


/// <summary>Binary result type discriminator. Use "image" for images and "resource" for other binary data.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ExternalToolTextResultForLlmBinaryResultsForLlmType : IEquatable<ExternalToolTextResultForLlmBinaryResultsForLlmType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ExternalToolTextResultForLlmBinaryResultsForLlmType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ExternalToolTextResultForLlmBinaryResultsForLlmType"/>.</param>
    [JsonConstructor]
    public ExternalToolTextResultForLlmBinaryResultsForLlmType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ExternalToolTextResultForLlmBinaryResultsForLlmType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Binary image data.</summary>
    public static ExternalToolTextResultForLlmBinaryResultsForLlmType Image { get; } = new("image");

    /// <summary>Other binary resource data.</summary>
    public static ExternalToolTextResultForLlmBinaryResultsForLlmType Resource { get; } = new("resource");

    /// <summary>Returns a value indicating whether two <see cref="ExternalToolTextResultForLlmBinaryResultsForLlmType"/> instances are equivalent.</summary>
    public static bool operator ==(ExternalToolTextResultForLlmBinaryResultsForLlmType left, ExternalToolTextResultForLlmBinaryResultsForLlmType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ExternalToolTextResultForLlmBinaryResultsForLlmType"/> instances are not equivalent.</summary>
    public static bool operator !=(ExternalToolTextResultForLlmBinaryResultsForLlmType left, ExternalToolTextResultForLlmBinaryResultsForLlmType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ExternalToolTextResultForLlmBinaryResultsForLlmType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ExternalToolTextResultForLlmBinaryResultsForLlmType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ExternalToolTextResultForLlmBinaryResultsForLlmType}"/> for serializing <see cref="ExternalToolTextResultForLlmBinaryResultsForLlmType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ExternalToolTextResultForLlmBinaryResultsForLlmType>
    {
        /// <inheritdoc />
        public override ExternalToolTextResultForLlmBinaryResultsForLlmType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ExternalToolTextResultForLlmBinaryResultsForLlmType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ExternalToolTextResultForLlmBinaryResultsForLlmType));
        }
    }
}


/// <summary>Theme variant this icon is intended for.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ExternalToolTextResultForLlmContentResourceLinkIconTheme : IEquatable<ExternalToolTextResultForLlmContentResourceLinkIconTheme>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ExternalToolTextResultForLlmContentResourceLinkIconTheme"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ExternalToolTextResultForLlmContentResourceLinkIconTheme"/>.</param>
    [JsonConstructor]
    public ExternalToolTextResultForLlmContentResourceLinkIconTheme(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ExternalToolTextResultForLlmContentResourceLinkIconTheme"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Icon intended for light themes.</summary>
    public static ExternalToolTextResultForLlmContentResourceLinkIconTheme Light { get; } = new("light");

    /// <summary>Icon intended for dark themes.</summary>
    public static ExternalToolTextResultForLlmContentResourceLinkIconTheme Dark { get; } = new("dark");

    /// <summary>Returns a value indicating whether two <see cref="ExternalToolTextResultForLlmContentResourceLinkIconTheme"/> instances are equivalent.</summary>
    public static bool operator ==(ExternalToolTextResultForLlmContentResourceLinkIconTheme left, ExternalToolTextResultForLlmContentResourceLinkIconTheme right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ExternalToolTextResultForLlmContentResourceLinkIconTheme"/> instances are not equivalent.</summary>
    public static bool operator !=(ExternalToolTextResultForLlmContentResourceLinkIconTheme left, ExternalToolTextResultForLlmContentResourceLinkIconTheme right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ExternalToolTextResultForLlmContentResourceLinkIconTheme other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ExternalToolTextResultForLlmContentResourceLinkIconTheme other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ExternalToolTextResultForLlmContentResourceLinkIconTheme}"/> for serializing <see cref="ExternalToolTextResultForLlmContentResourceLinkIconTheme"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ExternalToolTextResultForLlmContentResourceLinkIconTheme>
    {
        /// <inheritdoc />
        public override ExternalToolTextResultForLlmContentResourceLinkIconTheme Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ExternalToolTextResultForLlmContentResourceLinkIconTheme value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ExternalToolTextResultForLlmContentResourceLinkIconTheme));
        }
    }
}


/// <summary>Execution outcome classification.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ToolResultType : IEquatable<ToolResultType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ToolResultType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ToolResultType"/>.</param>
    [JsonConstructor]
    public ToolResultType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ToolResultType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The tool completed successfully.</summary>
    public static ToolResultType Success { get; } = new("success");

    /// <summary>The tool failed.</summary>
    public static ToolResultType Failure { get; } = new("failure");

    /// <summary>The tool exceeded its execution timeout.</summary>
    public static ToolResultType Timeout { get; } = new("timeout");

    /// <summary>The tool request was rejected before execution.</summary>
    public static ToolResultType Rejected { get; } = new("rejected");

    /// <summary>Permission policy denied the tool request.</summary>
    public static ToolResultType Denied { get; } = new("denied");

    /// <summary>Returns a value indicating whether two <see cref="ToolResultType"/> instances are equivalent.</summary>
    public static bool operator ==(ToolResultType left, ToolResultType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ToolResultType"/> instances are not equivalent.</summary>
    public static bool operator !=(ToolResultType left, ToolResultType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ToolResultType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ToolResultType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ToolResultType}"/> for serializing <see cref="ToolResultType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ToolResultType>
    {
        /// <inheritdoc />
        public override ToolResultType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ToolResultType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ToolResultType));
        }
    }
}


/// <summary>Controls whether the runtime may defer loading an external tool definition.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ProtocolExternalToolDefer : IEquatable<ProtocolExternalToolDefer>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ProtocolExternalToolDefer"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ProtocolExternalToolDefer"/>.</param>
    [JsonConstructor]
    public ProtocolExternalToolDefer(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ProtocolExternalToolDefer"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The runtime may defer the tool according to its tool-loading policy.</summary>
    public static ProtocolExternalToolDefer Auto { get; } = new("auto");

    /// <summary>The runtime must include the tool without deferring it.</summary>
    public static ProtocolExternalToolDefer Never { get; } = new("never");

    /// <summary>Returns a value indicating whether two <see cref="ProtocolExternalToolDefer"/> instances are equivalent.</summary>
    public static bool operator ==(ProtocolExternalToolDefer left, ProtocolExternalToolDefer right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ProtocolExternalToolDefer"/> instances are not equivalent.</summary>
    public static bool operator !=(ProtocolExternalToolDefer left, ProtocolExternalToolDefer right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ProtocolExternalToolDefer other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ProtocolExternalToolDefer other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ProtocolExternalToolDefer}"/> for serializing <see cref="ProtocolExternalToolDefer"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ProtocolExternalToolDefer>
    {
        /// <inheritdoc />
        public override ProtocolExternalToolDefer Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ProtocolExternalToolDefer value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ProtocolExternalToolDefer));
        }
    }
}


/// <summary>Context tier override for matching subagents.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SubagentSettingsEntryContextTier : IEquatable<SubagentSettingsEntryContextTier>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SubagentSettingsEntryContextTier"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SubagentSettingsEntryContextTier"/>.</param>
    [JsonConstructor]
    public SubagentSettingsEntryContextTier(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SubagentSettingsEntryContextTier"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Inherit the parent session's effective context tier at dispatch time.</summary>
    public static SubagentSettingsEntryContextTier Inherit { get; } = new("inherit");

    /// <summary>Use the model's default context window.</summary>
    public static SubagentSettingsEntryContextTier Default { get; } = new("default");

    /// <summary>Pin the subagent to the long-context tier when supported.</summary>
    public static SubagentSettingsEntryContextTier LongContext { get; } = new("long_context");

    /// <summary>Returns a value indicating whether two <see cref="SubagentSettingsEntryContextTier"/> instances are equivalent.</summary>
    public static bool operator ==(SubagentSettingsEntryContextTier left, SubagentSettingsEntryContextTier right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SubagentSettingsEntryContextTier"/> instances are not equivalent.</summary>
    public static bool operator !=(SubagentSettingsEntryContextTier left, SubagentSettingsEntryContextTier right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SubagentSettingsEntryContextTier other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SubagentSettingsEntryContextTier other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SubagentSettingsEntryContextTier}"/> for serializing <see cref="SubagentSettingsEntryContextTier"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SubagentSettingsEntryContextTier>
    {
        /// <inheritdoc />
        public override SubagentSettingsEntryContextTier Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SubagentSettingsEntryContextTier value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SubagentSettingsEntryContextTier));
        }
    }
}


/// <summary>Defines the allowed values.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CommandsInvocationOrigin : IEquatable<CommandsInvocationOrigin>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CommandsInvocationOrigin"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CommandsInvocationOrigin"/>.</param>
    [JsonConstructor]
    public CommandsInvocationOrigin(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CommandsInvocationOrigin"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Gets the <c>settings</c> value.</summary>
    public static CommandsInvocationOrigin Settings { get; } = new("settings");

    /// <summary>Returns a value indicating whether two <see cref="CommandsInvocationOrigin"/> instances are equivalent.</summary>
    public static bool operator ==(CommandsInvocationOrigin left, CommandsInvocationOrigin right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CommandsInvocationOrigin"/> instances are not equivalent.</summary>
    public static bool operator !=(CommandsInvocationOrigin left, CommandsInvocationOrigin right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CommandsInvocationOrigin other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CommandsInvocationOrigin other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CommandsInvocationOrigin}"/> for serializing <see cref="CommandsInvocationOrigin"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CommandsInvocationOrigin>
    {
        /// <inheritdoc />
        public override CommandsInvocationOrigin Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CommandsInvocationOrigin value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CommandsInvocationOrigin));
        }
    }
}


/// <summary>Whether a pending slash-command invocation effect was applied or cancelled by the host.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct CommandsInvocationEffectOutcome : IEquatable<CommandsInvocationEffectOutcome>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="CommandsInvocationEffectOutcome"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="CommandsInvocationEffectOutcome"/>.</param>
    [JsonConstructor]
    public CommandsInvocationEffectOutcome(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="CommandsInvocationEffectOutcome"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The host applied the pending invocation effect.</summary>
    public static CommandsInvocationEffectOutcome Applied { get; } = new("applied");

    /// <summary>The host cancelled the pending invocation effect, so any provisional state must be reverted.</summary>
    public static CommandsInvocationEffectOutcome Cancelled { get; } = new("cancelled");

    /// <summary>Returns a value indicating whether two <see cref="CommandsInvocationEffectOutcome"/> instances are equivalent.</summary>
    public static bool operator ==(CommandsInvocationEffectOutcome left, CommandsInvocationEffectOutcome right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="CommandsInvocationEffectOutcome"/> instances are not equivalent.</summary>
    public static bool operator !=(CommandsInvocationEffectOutcome left, CommandsInvocationEffectOutcome right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is CommandsInvocationEffectOutcome other && Equals(other);

    /// <inheritdoc />
    public bool Equals(CommandsInvocationEffectOutcome other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{CommandsInvocationEffectOutcome}"/> for serializing <see cref="CommandsInvocationEffectOutcome"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<CommandsInvocationEffectOutcome>
    {
        /// <inheritdoc />
        public override CommandsInvocationEffectOutcome Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, CommandsInvocationEffectOutcome value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(CommandsInvocationEffectOutcome));
        }
    }
}


/// <summary>The user's response: accept (submitted), decline (rejected), or cancel (dismissed).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct UIElicitationResponseAction : IEquatable<UIElicitationResponseAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="UIElicitationResponseAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="UIElicitationResponseAction"/>.</param>
    [JsonConstructor]
    public UIElicitationResponseAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="UIElicitationResponseAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The user submitted the requested form values.</summary>
    public static UIElicitationResponseAction Accept { get; } = new("accept");

    /// <summary>The user explicitly declined to provide the requested input.</summary>
    public static UIElicitationResponseAction Decline { get; } = new("decline");

    /// <summary>The user dismissed the elicitation request.</summary>
    public static UIElicitationResponseAction Cancel { get; } = new("cancel");

    /// <summary>Returns a value indicating whether two <see cref="UIElicitationResponseAction"/> instances are equivalent.</summary>
    public static bool operator ==(UIElicitationResponseAction left, UIElicitationResponseAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="UIElicitationResponseAction"/> instances are not equivalent.</summary>
    public static bool operator !=(UIElicitationResponseAction left, UIElicitationResponseAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is UIElicitationResponseAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(UIElicitationResponseAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{UIElicitationResponseAction}"/> for serializing <see cref="UIElicitationResponseAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<UIElicitationResponseAction>
    {
        /// <inheritdoc />
        public override UIElicitationResponseAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, UIElicitationResponseAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(UIElicitationResponseAction));
        }
    }
}


/// <summary>Structured MCP elicitation mode.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct McpElicitationFormMode : IEquatable<McpElicitationFormMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="McpElicitationFormMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="McpElicitationFormMode"/>.</param>
    [JsonConstructor]
    public McpElicitationFormMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="McpElicitationFormMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Gets the <c>form</c> value.</summary>
    public static McpElicitationFormMode Form { get; } = new("form");

    /// <summary>Returns a value indicating whether two <see cref="McpElicitationFormMode"/> instances are equivalent.</summary>
    public static bool operator ==(McpElicitationFormMode left, McpElicitationFormMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="McpElicitationFormMode"/> instances are not equivalent.</summary>
    public static bool operator !=(McpElicitationFormMode left, McpElicitationFormMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is McpElicitationFormMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(McpElicitationFormMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{McpElicitationFormMode}"/> for serializing <see cref="McpElicitationFormMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<McpElicitationFormMode>
    {
        /// <inheritdoc />
        public override McpElicitationFormMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, McpElicitationFormMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(McpElicitationFormMode));
        }
    }
}


/// <summary>User's choice for auto-mode switching: yes (allow this turn), yes_always (allow + persist as setting), or no (decline).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct UIAutoModeSwitchResponse : IEquatable<UIAutoModeSwitchResponse>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="UIAutoModeSwitchResponse"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="UIAutoModeSwitchResponse"/>.</param>
    [JsonConstructor]
    public UIAutoModeSwitchResponse(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="UIAutoModeSwitchResponse"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Allow the automatic mode switch for this turn.</summary>
    public static UIAutoModeSwitchResponse Yes { get; } = new("yes");

    /// <summary>Allow this mode switch and persist the preference.</summary>
    public static UIAutoModeSwitchResponse YesAlways { get; } = new("yes_always");

    /// <summary>Decline the automatic mode switch.</summary>
    public static UIAutoModeSwitchResponse No { get; } = new("no");

    /// <summary>Returns a value indicating whether two <see cref="UIAutoModeSwitchResponse"/> instances are equivalent.</summary>
    public static bool operator ==(UIAutoModeSwitchResponse left, UIAutoModeSwitchResponse right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="UIAutoModeSwitchResponse"/> instances are not equivalent.</summary>
    public static bool operator !=(UIAutoModeSwitchResponse left, UIAutoModeSwitchResponse right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is UIAutoModeSwitchResponse other && Equals(other);

    /// <inheritdoc />
    public bool Equals(UIAutoModeSwitchResponse other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{UIAutoModeSwitchResponse}"/> for serializing <see cref="UIAutoModeSwitchResponse"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<UIAutoModeSwitchResponse>
    {
        /// <inheritdoc />
        public override UIAutoModeSwitchResponse Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, UIAutoModeSwitchResponse value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(UIAutoModeSwitchResponse));
        }
    }
}


/// <summary>User action selected for an exhausted session limit.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct UISessionLimitsExhaustedResponseAction : IEquatable<UISessionLimitsExhaustedResponseAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="UISessionLimitsExhaustedResponseAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="UISessionLimitsExhaustedResponseAction"/>.</param>
    [JsonConstructor]
    public UISessionLimitsExhaustedResponseAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="UISessionLimitsExhaustedResponseAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Increase the current max by an exact AI Credits amount.</summary>
    public static UISessionLimitsExhaustedResponseAction Add { get; } = new("add");

    /// <summary>Set a new absolute max AI Credits value.</summary>
    public static UISessionLimitsExhaustedResponseAction Set { get; } = new("set");

    /// <summary>Remove the current session limit.</summary>
    public static UISessionLimitsExhaustedResponseAction Unset { get; } = new("unset");

    /// <summary>Leave the limit unchanged and cancel the blocked model request.</summary>
    public static UISessionLimitsExhaustedResponseAction Cancel { get; } = new("cancel");

    /// <summary>Returns a value indicating whether two <see cref="UISessionLimitsExhaustedResponseAction"/> instances are equivalent.</summary>
    public static bool operator ==(UISessionLimitsExhaustedResponseAction left, UISessionLimitsExhaustedResponseAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="UISessionLimitsExhaustedResponseAction"/> instances are not equivalent.</summary>
    public static bool operator !=(UISessionLimitsExhaustedResponseAction left, UISessionLimitsExhaustedResponseAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is UISessionLimitsExhaustedResponseAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(UISessionLimitsExhaustedResponseAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{UISessionLimitsExhaustedResponseAction}"/> for serializing <see cref="UISessionLimitsExhaustedResponseAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<UISessionLimitsExhaustedResponseAction>
    {
        /// <inheritdoc />
        public override UISessionLimitsExhaustedResponseAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, UISessionLimitsExhaustedResponseAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(UISessionLimitsExhaustedResponseAction));
        }
    }
}


/// <summary>The action the user selected. Defaults to 'autopilot' when autoApproveEdits is true, otherwise 'interactive'.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct UIExitPlanModeAction : IEquatable<UIExitPlanModeAction>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="UIExitPlanModeAction"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="UIExitPlanModeAction"/>.</param>
    [JsonConstructor]
    public UIExitPlanModeAction(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="UIExitPlanModeAction"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Exit plan mode without starting implementation.</summary>
    public static UIExitPlanModeAction ExitOnly { get; } = new("exit_only");

    /// <summary>Exit plan mode and continue interactively.</summary>
    public static UIExitPlanModeAction Interactive { get; } = new("interactive");

    /// <summary>Exit plan mode and continue in autopilot mode.</summary>
    public static UIExitPlanModeAction Autopilot { get; } = new("autopilot");

    /// <summary>Exit plan mode and continue in autopilot mode with parallel subagent execution.</summary>
    public static UIExitPlanModeAction AutopilotFleet { get; } = new("autopilot_fleet");

    /// <summary>Returns a value indicating whether two <see cref="UIExitPlanModeAction"/> instances are equivalent.</summary>
    public static bool operator ==(UIExitPlanModeAction left, UIExitPlanModeAction right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="UIExitPlanModeAction"/> instances are not equivalent.</summary>
    public static bool operator !=(UIExitPlanModeAction left, UIExitPlanModeAction right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is UIExitPlanModeAction other && Equals(other);

    /// <inheritdoc />
    public bool Equals(UIExitPlanModeAction other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{UIExitPlanModeAction}"/> for serializing <see cref="UIExitPlanModeAction"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<UIExitPlanModeAction>
    {
        /// <inheritdoc />
        public override UIExitPlanModeAction Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, UIExitPlanModeAction value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(UIExitPlanModeAction));
        }
    }
}


/// <summary>Allowed values for the `PermissionsConfigureAdditionalContentExclusionPolicyScope` enumeration.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionsConfigureAdditionalContentExclusionPolicyScope : IEquatable<PermissionsConfigureAdditionalContentExclusionPolicyScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionsConfigureAdditionalContentExclusionPolicyScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionsConfigureAdditionalContentExclusionPolicyScope"/>.</param>
    [JsonConstructor]
    public PermissionsConfigureAdditionalContentExclusionPolicyScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionsConfigureAdditionalContentExclusionPolicyScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The content exclusion policy applies to the current repository.</summary>
    public static PermissionsConfigureAdditionalContentExclusionPolicyScope Repo { get; } = new("repo");

    /// <summary>The content exclusion policy applies across all repositories.</summary>
    public static PermissionsConfigureAdditionalContentExclusionPolicyScope All { get; } = new("all");

    /// <summary>Returns a value indicating whether two <see cref="PermissionsConfigureAdditionalContentExclusionPolicyScope"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionsConfigureAdditionalContentExclusionPolicyScope left, PermissionsConfigureAdditionalContentExclusionPolicyScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionsConfigureAdditionalContentExclusionPolicyScope"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionsConfigureAdditionalContentExclusionPolicyScope left, PermissionsConfigureAdditionalContentExclusionPolicyScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionsConfigureAdditionalContentExclusionPolicyScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionsConfigureAdditionalContentExclusionPolicyScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionsConfigureAdditionalContentExclusionPolicyScope}"/> for serializing <see cref="PermissionsConfigureAdditionalContentExclusionPolicyScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionsConfigureAdditionalContentExclusionPolicyScope>
    {
        /// <inheritdoc />
        public override PermissionsConfigureAdditionalContentExclusionPolicyScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionsConfigureAdditionalContentExclusionPolicyScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionsConfigureAdditionalContentExclusionPolicyScope));
        }
    }
}


/// <summary>Optional source for allow-all telemetry. Defaults to `rpc` when omitted for SDK callers.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionsSetApproveAllSource : IEquatable<PermissionsSetApproveAllSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionsSetApproveAllSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionsSetApproveAllSource"/>.</param>
    [JsonConstructor]
    public PermissionsSetApproveAllSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionsSetApproveAllSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Allow-all was enabled from a CLI command-line flag.</summary>
    public static PermissionsSetApproveAllSource CliFlag { get; } = new("cli_flag");

    /// <summary>Allow-all was enabled by a slash command.</summary>
    public static PermissionsSetApproveAllSource SlashCommand { get; } = new("slash_command");

    /// <summary>Allow-all was enabled by confirming autopilot behavior.</summary>
    public static PermissionsSetApproveAllSource AutopilotConfirmation { get; } = new("autopilot_confirmation");

    /// <summary>Allow-all was enabled at startup by the `defaultPermissionMode` user setting.</summary>
    public static PermissionsSetApproveAllSource UserSetting { get; } = new("user_setting");

    /// <summary>Allow-all was enabled through an RPC caller.</summary>
    public static PermissionsSetApproveAllSource Rpc { get; } = new("rpc");

    /// <summary>Returns a value indicating whether two <see cref="PermissionsSetApproveAllSource"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionsSetApproveAllSource left, PermissionsSetApproveAllSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionsSetApproveAllSource"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionsSetApproveAllSource left, PermissionsSetApproveAllSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionsSetApproveAllSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionsSetApproveAllSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionsSetApproveAllSource}"/> for serializing <see cref="PermissionsSetApproveAllSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionsSetApproveAllSource>
    {
        /// <inheritdoc />
        public override PermissionsSetApproveAllSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionsSetApproveAllSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionsSetApproveAllSource));
        }
    }
}


/// <summary>Optional source for permission-mode telemetry. Defaults to `rpc` when omitted for SDK callers.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionModeSource : IEquatable<PermissionModeSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionModeSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionModeSource"/>.</param>
    [JsonConstructor]
    public PermissionModeSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionModeSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The mode was set from a CLI command-line flag.</summary>
    public static PermissionModeSource CliFlag { get; } = new("cli_flag");

    /// <summary>The mode was set by a slash command.</summary>
    public static PermissionModeSource SlashCommand { get; } = new("slash_command");

    /// <summary>The mode was set by confirming autopilot behavior.</summary>
    public static PermissionModeSource AutopilotConfirmation { get; } = new("autopilot_confirmation");

    /// <summary>The mode was set at startup by the `defaultPermissionMode` user setting.</summary>
    public static PermissionModeSource UserSetting { get; } = new("user_setting");

    /// <summary>The mode was set through an RPC caller.</summary>
    public static PermissionModeSource Rpc { get; } = new("rpc");

    /// <summary>Returns a value indicating whether two <see cref="PermissionModeSource"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionModeSource left, PermissionModeSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionModeSource"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionModeSource left, PermissionModeSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionModeSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionModeSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionModeSource}"/> for serializing <see cref="PermissionModeSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionModeSource>
    {
        /// <inheritdoc />
        public override PermissionModeSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionModeSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionModeSource));
        }
    }
}


/// <summary>Whether the change applies to ephemeral session-scoped rules (cleared at session end) or to location-scoped rules persisted via the location-permissions config file.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionsModifyRulesScope : IEquatable<PermissionsModifyRulesScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionsModifyRulesScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionsModifyRulesScope"/>.</param>
    [JsonConstructor]
    public PermissionsModifyRulesScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionsModifyRulesScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Apply the rule change only to this session.</summary>
    public static PermissionsModifyRulesScope Session { get; } = new("session");

    /// <summary>Persist the rule change for this project location.</summary>
    public static PermissionsModifyRulesScope Location { get; } = new("location");

    /// <summary>Returns a value indicating whether two <see cref="PermissionsModifyRulesScope"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionsModifyRulesScope left, PermissionsModifyRulesScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionsModifyRulesScope"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionsModifyRulesScope left, PermissionsModifyRulesScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionsModifyRulesScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionsModifyRulesScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionsModifyRulesScope}"/> for serializing <see cref="PermissionsModifyRulesScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionsModifyRulesScope>
    {
        /// <inheritdoc />
        public override PermissionsModifyRulesScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionsModifyRulesScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionsModifyRulesScope));
        }
    }
}


/// <summary>Whether the location is a git repo or directory.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct PermissionLocationType : IEquatable<PermissionLocationType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="PermissionLocationType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="PermissionLocationType"/>.</param>
    [JsonConstructor]
    public PermissionLocationType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="PermissionLocationType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The permission location is persisted at the git repository root.</summary>
    public static PermissionLocationType Repo { get; } = new("repo");

    /// <summary>The permission location is persisted at the working directory.</summary>
    public static PermissionLocationType Dir { get; } = new("dir");

    /// <summary>Returns a value indicating whether two <see cref="PermissionLocationType"/> instances are equivalent.</summary>
    public static bool operator ==(PermissionLocationType left, PermissionLocationType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="PermissionLocationType"/> instances are not equivalent.</summary>
    public static bool operator !=(PermissionLocationType left, PermissionLocationType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is PermissionLocationType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(PermissionLocationType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{PermissionLocationType}"/> for serializing <see cref="PermissionLocationType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<PermissionLocationType>
    {
        /// <inheritdoc />
        public override PermissionLocationType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, PermissionLocationType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(PermissionLocationType));
        }
    }
}


/// <summary>The current agent mode for this session (e.g., 'interactive', 'plan', 'autopilot').</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct MetadataSnapshotCurrentMode : IEquatable<MetadataSnapshotCurrentMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="MetadataSnapshotCurrentMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="MetadataSnapshotCurrentMode"/>.</param>
    [JsonConstructor]
    public MetadataSnapshotCurrentMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="MetadataSnapshotCurrentMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The agent is responding interactively to the user.</summary>
    public static MetadataSnapshotCurrentMode Interactive { get; } = new("interactive");

    /// <summary>The agent is preparing a plan before making changes.</summary>
    public static MetadataSnapshotCurrentMode Plan { get; } = new("plan");

    /// <summary>The agent is working autonomously toward task completion.</summary>
    public static MetadataSnapshotCurrentMode Autopilot { get; } = new("autopilot");

    /// <summary>Returns a value indicating whether two <see cref="MetadataSnapshotCurrentMode"/> instances are equivalent.</summary>
    public static bool operator ==(MetadataSnapshotCurrentMode left, MetadataSnapshotCurrentMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="MetadataSnapshotCurrentMode"/> instances are not equivalent.</summary>
    public static bool operator !=(MetadataSnapshotCurrentMode left, MetadataSnapshotCurrentMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is MetadataSnapshotCurrentMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(MetadataSnapshotCurrentMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{MetadataSnapshotCurrentMode}"/> for serializing <see cref="MetadataSnapshotCurrentMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<MetadataSnapshotCurrentMode>
    {
        /// <inheritdoc />
        public override MetadataSnapshotCurrentMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, MetadataSnapshotCurrentMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(MetadataSnapshotCurrentMode));
        }
    }
}


/// <summary>Whether the remote task originated from Copilot Coding Agent (cca) or a CLI `--remote` invocation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct MetadataSnapshotRemoteMetadataTaskType : IEquatable<MetadataSnapshotRemoteMetadataTaskType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="MetadataSnapshotRemoteMetadataTaskType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="MetadataSnapshotRemoteMetadataTaskType"/>.</param>
    [JsonConstructor]
    public MetadataSnapshotRemoteMetadataTaskType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="MetadataSnapshotRemoteMetadataTaskType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Remote task originated from Copilot Coding Agent.</summary>
    public static MetadataSnapshotRemoteMetadataTaskType Cca { get; } = new("cca");

    /// <summary>Remote task originated from a CLI remote-session invocation.</summary>
    public static MetadataSnapshotRemoteMetadataTaskType Cli { get; } = new("cli");

    /// <summary>Returns a value indicating whether two <see cref="MetadataSnapshotRemoteMetadataTaskType"/> instances are equivalent.</summary>
    public static bool operator ==(MetadataSnapshotRemoteMetadataTaskType left, MetadataSnapshotRemoteMetadataTaskType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="MetadataSnapshotRemoteMetadataTaskType"/> instances are not equivalent.</summary>
    public static bool operator !=(MetadataSnapshotRemoteMetadataTaskType left, MetadataSnapshotRemoteMetadataTaskType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is MetadataSnapshotRemoteMetadataTaskType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(MetadataSnapshotRemoteMetadataTaskType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{MetadataSnapshotRemoteMetadataTaskType}"/> for serializing <see cref="MetadataSnapshotRemoteMetadataTaskType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<MetadataSnapshotRemoteMetadataTaskType>
    {
        /// <inheritdoc />
        public override MetadataSnapshotRemoteMetadataTaskType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, MetadataSnapshotRemoteMetadataTaskType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(MetadataSnapshotRemoteMetadataTaskType));
        }
    }
}


/// <summary>Repository host type, if known.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct WorkspaceSummaryHostType : IEquatable<WorkspaceSummaryHostType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="WorkspaceSummaryHostType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="WorkspaceSummaryHostType"/>.</param>
    [JsonConstructor]
    public WorkspaceSummaryHostType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="WorkspaceSummaryHostType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Workspace summary repository is hosted on GitHub.</summary>
    public static WorkspaceSummaryHostType GitHub { get; } = new("github");

    /// <summary>Workspace summary repository is hosted on Azure DevOps.</summary>
    public static WorkspaceSummaryHostType Ado { get; } = new("ado");

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceSummaryHostType"/> instances are equivalent.</summary>
    public static bool operator ==(WorkspaceSummaryHostType left, WorkspaceSummaryHostType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="WorkspaceSummaryHostType"/> instances are not equivalent.</summary>
    public static bool operator !=(WorkspaceSummaryHostType left, WorkspaceSummaryHostType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is WorkspaceSummaryHostType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(WorkspaceSummaryHostType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{WorkspaceSummaryHostType}"/> for serializing <see cref="WorkspaceSummaryHostType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<WorkspaceSummaryHostType>
    {
        /// <inheritdoc />
        public override WorkspaceSummaryHostType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, WorkspaceSummaryHostType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(WorkspaceSummaryHostType));
        }
    }
}


/// <summary>Hosting platform type of the repository.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionWorkingDirectoryContextHostType : IEquatable<SessionWorkingDirectoryContextHostType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionWorkingDirectoryContextHostType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionWorkingDirectoryContextHostType"/>.</param>
    [JsonConstructor]
    public SessionWorkingDirectoryContextHostType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionWorkingDirectoryContextHostType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The working directory repository is hosted on GitHub.</summary>
    public static SessionWorkingDirectoryContextHostType GitHub { get; } = new("github");

    /// <summary>The working directory repository is hosted on Azure DevOps.</summary>
    public static SessionWorkingDirectoryContextHostType Ado { get; } = new("ado");

    /// <summary>Returns a value indicating whether two <see cref="SessionWorkingDirectoryContextHostType"/> instances are equivalent.</summary>
    public static bool operator ==(SessionWorkingDirectoryContextHostType left, SessionWorkingDirectoryContextHostType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionWorkingDirectoryContextHostType"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionWorkingDirectoryContextHostType left, SessionWorkingDirectoryContextHostType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionWorkingDirectoryContextHostType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionWorkingDirectoryContextHostType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionWorkingDirectoryContextHostType}"/> for serializing <see cref="SessionWorkingDirectoryContextHostType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionWorkingDirectoryContextHostType>
    {
        /// <inheritdoc />
        public override SessionWorkingDirectoryContextHostType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionWorkingDirectoryContextHostType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionWorkingDirectoryContextHostType));
        }
    }
}


/// <summary>Rust-owned settings predicates exposed across the SDK boundary. Raw feature-flag names are intentionally not part of the contract.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionSettingsPredicateName : IEquatable<SessionSettingsPredicateName>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionSettingsPredicateName"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionSettingsPredicateName"/>.</param>
    [JsonConstructor]
    public SessionSettingsPredicateName(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionSettingsPredicateName"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Whether the security-tools feature flag enables security tool wiring.</summary>
    public static SessionSettingsPredicateName SecurityToolsEnabled { get; } = new("securityToolsEnabled");

    /// <summary>Whether third-party security tools should receive the security prompt.</summary>
    public static SessionSettingsPredicateName ThirdPartySecurityPromptEnabled { get; } = new("thirdPartySecurityPromptEnabled");

    /// <summary>Whether validation may run in parallel.</summary>
    public static SessionSettingsPredicateName ParallelValidationEnabled { get; } = new("parallelValidationEnabled");

    /// <summary>Whether runtime timing telemetry is enabled.</summary>
    public static SessionSettingsPredicateName RuntimeTimingTelemetryEnabled { get; } = new("runtimeTimingTelemetryEnabled");

    /// <summary>Whether the co-author hook is enabled.</summary>
    public static SessionSettingsPredicateName CoAuthorHookEnabled { get; } = new("coAuthorHookEnabled");

    /// <summary>Whether Chronicle integration is enabled.</summary>
    public static SessionSettingsPredicateName ChronicleEnabled { get; } = new("chronicleEnabled");

    /// <summary>Whether content-exclusion policy may self-fetch data.</summary>
    public static SessionSettingsPredicateName ContentExclusionSelfFetchEnabled { get; } = new("contentExclusionSelfFetchEnabled");

    /// <summary>Whether Claude Opus token-limit caps should be applied.</summary>
    public static SessionSettingsPredicateName CapClaudeOpusTokenLimitsEnabled { get; } = new("capClaudeOpusTokenLimitsEnabled");

    /// <summary>Whether code-review behavior is enabled.</summary>
    public static SessionSettingsPredicateName CodeReviewFeatureEnabled { get; } = new("codeReviewFeatureEnabled");

    /// <summary>Whether CCA should use the TypeScript autofind behavior.</summary>
    public static SessionSettingsPredicateName CcaUseTsAutofindEnabled { get; } = new("ccaUseTsAutofindEnabled");

    /// <summary>Whether the dependency checker is enabled.</summary>
    public static SessionSettingsPredicateName DependencyCheckerEnabled { get; } = new("dependencyCheckerEnabled");

    /// <summary>Whether the Dependabot checker is enabled.</summary>
    public static SessionSettingsPredicateName DependabotCheckerEnabled { get; } = new("dependabotCheckerEnabled");

    /// <summary>Whether the CodeQL checker is enabled.</summary>
    public static SessionSettingsPredicateName CodeqlCheckerEnabled { get; } = new("codeqlCheckerEnabled");

    /// <summary>Whether trivial-change handling is enabled.</summary>
    public static SessionSettingsPredicateName TrivialChangeEnabled { get; } = new("trivialChangeEnabled");

    /// <summary>Whether trivial-change skip behavior is enabled.</summary>
    public static SessionSettingsPredicateName TrivialChangeSkipEnabled { get; } = new("trivialChangeSkipEnabled");

    /// <summary>Whether trivial-change handling is enabled for code review.</summary>
    public static SessionSettingsPredicateName TrivialChangeEnabledForCodeReview { get; } = new("trivialChangeEnabledForCodeReview");

    /// <summary>Whether trivial-change skip behavior is enabled for code review.</summary>
    public static SessionSettingsPredicateName TrivialChangeSkipEnabledForCodeReview { get; } = new("trivialChangeSkipEnabledForCodeReview");

    /// <summary>Whether trivial-change handling is enabled for a specific tool.</summary>
    public static SessionSettingsPredicateName TrivialChangeEnabledForTool { get; } = new("trivialChangeEnabledForTool");

    /// <summary>Whether trivial-change skip behavior is enabled for a specific tool.</summary>
    public static SessionSettingsPredicateName TrivialChangeSkipEnabledForTool { get; } = new("trivialChangeSkipEnabledForTool");

    /// <summary>Returns a value indicating whether two <see cref="SessionSettingsPredicateName"/> instances are equivalent.</summary>
    public static bool operator ==(SessionSettingsPredicateName left, SessionSettingsPredicateName right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionSettingsPredicateName"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionSettingsPredicateName left, SessionSettingsPredicateName right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionSettingsPredicateName other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionSettingsPredicateName other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionSettingsPredicateName}"/> for serializing <see cref="SessionSettingsPredicateName"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionSettingsPredicateName>
    {
        /// <inheritdoc />
        public override SessionSettingsPredicateName Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionSettingsPredicateName value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionSettingsPredicateName));
        }
    }
}


/// <summary>Signal to send (default: SIGTERM).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ShellKillSignal : IEquatable<ShellKillSignal>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ShellKillSignal"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ShellKillSignal"/>.</param>
    [JsonConstructor]
    public ShellKillSignal(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ShellKillSignal"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Request graceful process termination.</summary>
    public static ShellKillSignal SIGTERM { get; } = new("SIGTERM");

    /// <summary>Forcefully terminate the process.</summary>
    public static ShellKillSignal SIGKILL { get; } = new("SIGKILL");

    /// <summary>Send an interrupt signal to the process.</summary>
    public static ShellKillSignal SIGINT { get; } = new("SIGINT");

    /// <summary>Returns a value indicating whether two <see cref="ShellKillSignal"/> instances are equivalent.</summary>
    public static bool operator ==(ShellKillSignal left, ShellKillSignal right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ShellKillSignal"/> instances are not equivalent.</summary>
    public static bool operator !=(ShellKillSignal left, ShellKillSignal right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ShellKillSignal other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ShellKillSignal other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ShellKillSignal}"/> for serializing <see cref="ShellKillSignal"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ShellKillSignal>
    {
        /// <inheritdoc />
        public override ShellKillSignal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ShellKillSignal value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ShellKillSignal));
        }
    }
}


/// <summary>What initiated this compaction request, recorded as the `trigger` on the persisted `session.compaction_start` / `session.compaction_complete` events. When absent, the compaction is persisted without trigger attribution (initiator unknown).</summary>
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionHistoryCompactRequestTrigger : IEquatable<SessionHistoryCompactRequestTrigger>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionHistoryCompactRequestTrigger"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionHistoryCompactRequestTrigger"/>.</param>
    [JsonConstructor]
    public SessionHistoryCompactRequestTrigger(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionHistoryCompactRequestTrigger"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>User-requested compaction, e.g. the /compact command or a direct history.compact call.</summary>
    public static SessionHistoryCompactRequestTrigger Manual { get; } = new("manual");

    /// <summary>Compaction requested while switching to a model with a smaller context window.</summary>
    public static SessionHistoryCompactRequestTrigger ModelSwitch { get; } = new("model_switch");

    /// <summary>Returns a value indicating whether two <see cref="SessionHistoryCompactRequestTrigger"/> instances are equivalent.</summary>
    public static bool operator ==(SessionHistoryCompactRequestTrigger left, SessionHistoryCompactRequestTrigger right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionHistoryCompactRequestTrigger"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionHistoryCompactRequestTrigger left, SessionHistoryCompactRequestTrigger right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionHistoryCompactRequestTrigger other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionHistoryCompactRequestTrigger other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionHistoryCompactRequestTrigger}"/> for serializing <see cref="SessionHistoryCompactRequestTrigger"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionHistoryCompactRequestTrigger>
    {
        /// <inheritdoc />
        public override SessionHistoryCompactRequestTrigger Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionHistoryCompactRequestTrigger value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionHistoryCompactRequestTrigger));
        }
    }
}


/// <summary>Aggregate file change represented by a rewind preview.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HistoryRewindChangeType : IEquatable<HistoryRewindChangeType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HistoryRewindChangeType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HistoryRewindChangeType"/>.</param>
    [JsonConstructor]
    public HistoryRewindChangeType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HistoryRewindChangeType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The discarded turns created the file.</summary>
    public static HistoryRewindChangeType Created { get; } = new("created");

    /// <summary>The discarded turns deleted the file.</summary>
    public static HistoryRewindChangeType Deleted { get; } = new("deleted");

    /// <summary>The discarded turns modified the file.</summary>
    public static HistoryRewindChangeType Modified { get; } = new("modified");

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindChangeType"/> instances are equivalent.</summary>
    public static bool operator ==(HistoryRewindChangeType left, HistoryRewindChangeType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindChangeType"/> instances are not equivalent.</summary>
    public static bool operator !=(HistoryRewindChangeType left, HistoryRewindChangeType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HistoryRewindChangeType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HistoryRewindChangeType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HistoryRewindChangeType}"/> for serializing <see cref="HistoryRewindChangeType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HistoryRewindChangeType>
    {
        /// <inheritdoc />
        public override HistoryRewindChangeType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HistoryRewindChangeType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HistoryRewindChangeType));
        }
    }
}


/// <summary>Outcome of a rewind request.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HistoryRewindOutcome : IEquatable<HistoryRewindOutcome>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HistoryRewindOutcome"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HistoryRewindOutcome"/>.</param>
    [JsonConstructor]
    public HistoryRewindOutcome(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HistoryRewindOutcome"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The requested rewind completed; reachable in either mode.</summary>
    public static HistoryRewindOutcome Success { get; } = new("success");

    /// <summary>The session still has work that may mutate files or history; reachable in either mode.</summary>
    public static HistoryRewindOutcome SessionBusy { get; } = new("session-busy");

    /// <summary>A conversation-and-files rewind was requested for a session that did not enable capture; conversation-only rewinds never produce this.</summary>
    public static HistoryRewindOutcome FileChangeTrackingDisabled { get; } = new("file-change-tracking-disabled");

    /// <summary>Remote-backed rewind routing is not supported; reachable in either mode.</summary>
    public static HistoryRewindOutcome UnsupportedRemoteSession { get; } = new("unsupported-remote-session");

    /// <summary>File restore failed and all applied file changes were rolled back; only conversation-and-files rewinds produce this.</summary>
    public static HistoryRewindOutcome FilesRolledBack { get; } = new("files-rolled-back");

    /// <summary>File restore failed and its rollback could not fully restore the pre-rewind state; only conversation-and-files rewinds produce this.</summary>
    public static HistoryRewindOutcome RollbackIncomplete { get; } = new("rollback-incomplete");

    /// <summary>Conversation truncation failed. In conversation-and-files mode any files that were restored are left in place because conversation history cannot be un-truncated; in conversation-only mode no files are restored. Consult restoredFiles for what, if anything, was applied.</summary>
    public static HistoryRewindOutcome TruncationFailed { get; } = new("truncation-failed");

    /// <summary>The conversation was rewound (and, in conversation-and-files mode, captured files were restored), but persisted checkpoints could not be cleaned up; reachable in either mode.</summary>
    public static HistoryRewindOutcome CheckpointCleanupFailed { get; } = new("checkpoint-cleanup-failed");

    /// <summary>Files and conversation were rewound, but obsolete file snapshots could not be removed; only conversation-and-files rewinds produce this.</summary>
    public static HistoryRewindOutcome SnapshotPruneFailed { get; } = new("snapshot-prune-failed");

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindOutcome"/> instances are equivalent.</summary>
    public static bool operator ==(HistoryRewindOutcome left, HistoryRewindOutcome right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindOutcome"/> instances are not equivalent.</summary>
    public static bool operator !=(HistoryRewindOutcome left, HistoryRewindOutcome right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HistoryRewindOutcome other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HistoryRewindOutcome other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HistoryRewindOutcome}"/> for serializing <see cref="HistoryRewindOutcome"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HistoryRewindOutcome>
    {
        /// <inheritdoc />
        public override HistoryRewindOutcome Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HistoryRewindOutcome value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HistoryRewindOutcome));
        }
    }
}


/// <summary>Reason a captured file was not restored.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HistoryFileRestoreSkipReason : IEquatable<HistoryFileRestoreSkipReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HistoryFileRestoreSkipReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HistoryFileRestoreSkipReason"/>.</param>
    [JsonConstructor]
    public HistoryFileRestoreSkipReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HistoryFileRestoreSkipReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The file changed after Copilot's last captured write.</summary>
    public static HistoryFileRestoreSkipReason UserModified { get; } = new("user-modified");

    /// <summary>A faithful preimage was not captured.</summary>
    public static HistoryFileRestoreSkipReason SkippedCapture { get; } = new("skipped-capture");

    /// <summary>Returns a value indicating whether two <see cref="HistoryFileRestoreSkipReason"/> instances are equivalent.</summary>
    public static bool operator ==(HistoryFileRestoreSkipReason left, HistoryFileRestoreSkipReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HistoryFileRestoreSkipReason"/> instances are not equivalent.</summary>
    public static bool operator !=(HistoryFileRestoreSkipReason left, HistoryFileRestoreSkipReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HistoryFileRestoreSkipReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HistoryFileRestoreSkipReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HistoryFileRestoreSkipReason}"/> for serializing <see cref="HistoryFileRestoreSkipReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HistoryFileRestoreSkipReason>
    {
        /// <inheritdoc />
        public override HistoryFileRestoreSkipReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HistoryFileRestoreSkipReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HistoryFileRestoreSkipReason));
        }
    }
}


/// <summary>Scope of a rewind operation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct HistoryRewindMode : IEquatable<HistoryRewindMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="HistoryRewindMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="HistoryRewindMode"/>.</param>
    [JsonConstructor]
    public HistoryRewindMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="HistoryRewindMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Discard conversation events while leaving files unchanged.</summary>
    public static HistoryRewindMode Conversation { get; } = new("conversation");

    /// <summary>Discard conversation events and restore captured files changed by those turns.</summary>
    public static HistoryRewindMode ConversationAndFiles { get; } = new("conversation-and-files");

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindMode"/> instances are equivalent.</summary>
    public static bool operator ==(HistoryRewindMode left, HistoryRewindMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="HistoryRewindMode"/> instances are not equivalent.</summary>
    public static bool operator !=(HistoryRewindMode left, HistoryRewindMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is HistoryRewindMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(HistoryRewindMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{HistoryRewindMode}"/> for serializing <see cref="HistoryRewindMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<HistoryRewindMode>
    {
        /// <inheritdoc />
        public override HistoryRewindMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, HistoryRewindMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(HistoryRewindMode));
        }
    }
}


/// <summary>Whether this item is a queued user message or a queued slash command / model change.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct QueuePendingItemsKind : IEquatable<QueuePendingItemsKind>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="QueuePendingItemsKind"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="QueuePendingItemsKind"/>.</param>
    [JsonConstructor]
    public QueuePendingItemsKind(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="QueuePendingItemsKind"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A queued user message.</summary>
    public static QueuePendingItemsKind Message { get; } = new("message");

    /// <summary>A queued slash command or model-change command.</summary>
    public static QueuePendingItemsKind Command { get; } = new("command");

    /// <summary>Returns a value indicating whether two <see cref="QueuePendingItemsKind"/> instances are equivalent.</summary>
    public static bool operator ==(QueuePendingItemsKind left, QueuePendingItemsKind right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="QueuePendingItemsKind"/> instances are not equivalent.</summary>
    public static bool operator !=(QueuePendingItemsKind left, QueuePendingItemsKind right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is QueuePendingItemsKind other && Equals(other);

    /// <inheritdoc />
    public bool Equals(QueuePendingItemsKind other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{QueuePendingItemsKind}"/> for serializing <see cref="QueuePendingItemsKind"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<QueuePendingItemsKind>
    {
        /// <inheritdoc />
        public override QueuePendingItemsKind Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, QueuePendingItemsKind value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(QueuePendingItemsKind));
        }
    }
}


/// <summary>Agent-scope filter: 'primary' returns only main-agent events plus events whose type starts with 'subagent.' (matching the typed-subscription default behavior); 'all' returns events from all agents (matching wildcard-subscription behavior). Default is 'all' to preserve wildcard semantics for catch-up callers.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct EventsAgentScope : IEquatable<EventsAgentScope>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="EventsAgentScope"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="EventsAgentScope"/>.</param>
    [JsonConstructor]
    public EventsAgentScope(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="EventsAgentScope"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Return main-agent events and typed subagent lifecycle events.</summary>
    public static EventsAgentScope Primary { get; } = new("primary");

    /// <summary>Return events from all agents.</summary>
    public static EventsAgentScope All { get; } = new("all");

    /// <summary>Returns a value indicating whether two <see cref="EventsAgentScope"/> instances are equivalent.</summary>
    public static bool operator ==(EventsAgentScope left, EventsAgentScope right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="EventsAgentScope"/> instances are not equivalent.</summary>
    public static bool operator !=(EventsAgentScope left, EventsAgentScope right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is EventsAgentScope other && Equals(other);

    /// <inheritdoc />
    public bool Equals(EventsAgentScope other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{EventsAgentScope}"/> for serializing <see cref="EventsAgentScope"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<EventsAgentScope>
    {
        /// <inheritdoc />
        public override EventsAgentScope Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, EventsAgentScope value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(EventsAgentScope));
        }
    }
}


/// <summary>Client population used for the prediction baseline.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionLimitPredictionClientType : IEquatable<SessionLimitPredictionClientType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionLimitPredictionClientType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionLimitPredictionClientType"/>.</param>
    [JsonConstructor]
    public SessionLimitPredictionClientType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionLimitPredictionClientType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Interactive CLI sessions where a user can accept, edit, or top up the limit.</summary>
    public static SessionLimitPredictionClientType CliInteractive { get; } = new("cli-interactive");

    /// <summary>Prompt/non-interactive CLI sessions where the initial limit must cover more of the run.</summary>
    public static SessionLimitPredictionClientType CliPrompt { get; } = new("cli-prompt");

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionClientType"/> instances are equivalent.</summary>
    public static bool operator ==(SessionLimitPredictionClientType left, SessionLimitPredictionClientType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionClientType"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionLimitPredictionClientType left, SessionLimitPredictionClientType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionLimitPredictionClientType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionLimitPredictionClientType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionLimitPredictionClientType}"/> for serializing <see cref="SessionLimitPredictionClientType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionLimitPredictionClientType>
    {
        /// <inheritdoc />
        public override SessionLimitPredictionClientType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionLimitPredictionClientType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionLimitPredictionClientType));
        }
    }
}


/// <summary>Semantic usage tier used for a recommended cap or additional headroom.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionLimitPredictionTier : IEquatable<SessionLimitPredictionTier>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionLimitPredictionTier"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionLimitPredictionTier"/>.</param>
    [JsonConstructor]
    public SessionLimitPredictionTier(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionLimitPredictionTier"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Recommended starting tier.</summary>
    public static SessionLimitPredictionTier Recommended { get; } = new("recommended");

    /// <summary>Additional headroom for longer-running sessions.</summary>
    public static SessionLimitPredictionTier AdditionalHeadroom { get; } = new("additional_headroom");

    /// <summary>Generous headroom for unusually high usage.</summary>
    public static SessionLimitPredictionTier GenerousHeadroom { get; } = new("generous_headroom");

    /// <summary>Maximum available headroom tier.</summary>
    public static SessionLimitPredictionTier MaximumHeadroom { get; } = new("maximum_headroom");

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionTier"/> instances are equivalent.</summary>
    public static bool operator ==(SessionLimitPredictionTier left, SessionLimitPredictionTier right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionTier"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionLimitPredictionTier left, SessionLimitPredictionTier right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionLimitPredictionTier other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionLimitPredictionTier other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionLimitPredictionTier}"/> for serializing <see cref="SessionLimitPredictionTier"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionLimitPredictionTier>
    {
        /// <inheritdoc />
        public override SessionLimitPredictionTier Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionLimitPredictionTier value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionLimitPredictionTier));
        }
    }
}


/// <summary>Baseline fallback level used to create the prediction.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionLimitPredictionSource : IEquatable<SessionLimitPredictionSource>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionLimitPredictionSource"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionLimitPredictionSource"/>.</param>
    [JsonConstructor]
    public SessionLimitPredictionSource(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionLimitPredictionSource"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The prediction used the exact resolved model's baseline cell.</summary>
    public static SessionLimitPredictionSource Model { get; } = new("model");

    /// <summary>The exact model was unavailable, so the prediction used the model family's baseline cell.</summary>
    public static SessionLimitPredictionSource Family { get; } = new("family");

    /// <summary>No model or family cell was available, so the prediction used the global client-type baseline cell.</summary>
    public static SessionLimitPredictionSource Global { get; } = new("global");

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionSource"/> instances are equivalent.</summary>
    public static bool operator ==(SessionLimitPredictionSource left, SessionLimitPredictionSource right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionSource"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionLimitPredictionSource left, SessionLimitPredictionSource right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionLimitPredictionSource other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionLimitPredictionSource other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionLimitPredictionSource}"/> for serializing <see cref="SessionLimitPredictionSource"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionLimitPredictionSource>
    {
        /// <inheritdoc />
        public override SessionLimitPredictionSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionLimitPredictionSource value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionLimitPredictionSource));
        }
    }
}


/// <summary>Reason a prediction could not be computed.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionLimitPredictionUnavailableReason : IEquatable<SessionLimitPredictionUnavailableReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionLimitPredictionUnavailableReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionLimitPredictionUnavailableReason"/>.</param>
    [JsonConstructor]
    public SessionLimitPredictionUnavailableReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionLimitPredictionUnavailableReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The current model is auto and has not resolved to a concrete model yet.</summary>
    public static SessionLimitPredictionUnavailableReason AutoUnresolved { get; } = new("auto_unresolved");

    /// <summary>No model was provided and the session does not currently have a selected model.</summary>
    public static SessionLimitPredictionUnavailableReason NoModel { get; } = new("no_model");

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionUnavailableReason"/> instances are equivalent.</summary>
    public static bool operator ==(SessionLimitPredictionUnavailableReason left, SessionLimitPredictionUnavailableReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionLimitPredictionUnavailableReason"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionLimitPredictionUnavailableReason left, SessionLimitPredictionUnavailableReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionLimitPredictionUnavailableReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionLimitPredictionUnavailableReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionLimitPredictionUnavailableReason}"/> for serializing <see cref="SessionLimitPredictionUnavailableReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionLimitPredictionUnavailableReason>
    {
        /// <inheritdoc />
        public override SessionLimitPredictionUnavailableReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionLimitPredictionUnavailableReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionLimitPredictionUnavailableReason));
        }
    }
}


/// <summary>Per-session remote mode. "off" disables remote, "export" exports session events to GitHub without enabling remote steering, "on" enables both export and remote steering.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct RemoteSessionMode : IEquatable<RemoteSessionMode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="RemoteSessionMode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="RemoteSessionMode"/>.</param>
    [JsonConstructor]
    public RemoteSessionMode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="RemoteSessionMode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Disable remote session export and steering.</summary>
    public static RemoteSessionMode Off { get; } = new("off");

    /// <summary>Export session events to GitHub without enabling remote steering.</summary>
    public static RemoteSessionMode Export { get; } = new("export");

    /// <summary>Enable both remote session export and remote steering.</summary>
    public static RemoteSessionMode On { get; } = new("on");

    /// <summary>Returns a value indicating whether two <see cref="RemoteSessionMode"/> instances are equivalent.</summary>
    public static bool operator ==(RemoteSessionMode left, RemoteSessionMode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="RemoteSessionMode"/> instances are not equivalent.</summary>
    public static bool operator !=(RemoteSessionMode left, RemoteSessionMode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is RemoteSessionMode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(RemoteSessionMode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{RemoteSessionMode}"/> for serializing <see cref="RemoteSessionMode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<RemoteSessionMode>
    {
        /// <inheritdoc />
        public override RemoteSessionMode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, RemoteSessionMode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(RemoteSessionMode));
        }
    }
}


/// <summary>Sharing status for a synced session. "repo" makes the session visible to anyone with read access to the repository; "unshared" restricts it to the creator and collaborators.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionVisibilityStatus : IEquatable<SessionVisibilityStatus>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionVisibilityStatus"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionVisibilityStatus"/>.</param>
    [JsonConstructor]
    public SessionVisibilityStatus(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionVisibilityStatus"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The session is visible to repository readers.</summary>
    public static SessionVisibilityStatus Repo { get; } = new("repo");

    /// <summary>The session is restricted to its creator and collaborators.</summary>
    public static SessionVisibilityStatus Unshared { get; } = new("unshared");

    /// <summary>Returns a value indicating whether two <see cref="SessionVisibilityStatus"/> instances are equivalent.</summary>
    public static bool operator ==(SessionVisibilityStatus left, SessionVisibilityStatus right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionVisibilityStatus"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionVisibilityStatus left, SessionVisibilityStatus right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionVisibilityStatus other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionVisibilityStatus other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionVisibilityStatus}"/> for serializing <see cref="SessionVisibilityStatus"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionVisibilityStatus>
    {
        /// <inheritdoc />
        public override SessionVisibilityStatus Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionVisibilityStatus value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionVisibilityStatus));
        }
    }
}


/// <summary>Why the runtime requests client-task cancellation.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct ClientTaskCancelReason : IEquatable<ClientTaskCancelReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="ClientTaskCancelReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="ClientTaskCancelReason"/>.</param>
    [JsonConstructor]
    public ClientTaskCancelReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="ClientTaskCancelReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>A caller requested task cancellation.</summary>
    public static ClientTaskCancelReason CancelRequested { get; } = new("cancel_requested");

    /// <summary>The session is shutting down.</summary>
    public static ClientTaskCancelReason SessionShutdown { get; } = new("session_shutdown");

    /// <summary>Returns a value indicating whether two <see cref="ClientTaskCancelReason"/> instances are equivalent.</summary>
    public static bool operator ==(ClientTaskCancelReason left, ClientTaskCancelReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="ClientTaskCancelReason"/> instances are not equivalent.</summary>
    public static bool operator !=(ClientTaskCancelReason left, ClientTaskCancelReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is ClientTaskCancelReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(ClientTaskCancelReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{ClientTaskCancelReason}"/> for serializing <see cref="ClientTaskCancelReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<ClientTaskCancelReason>
    {
        /// <inheritdoc />
        public override ClientTaskCancelReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, ClientTaskCancelReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(ClientTaskCancelReason));
        }
    }
}


/// <summary>Error classification.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionFsErrorCode : IEquatable<SessionFsErrorCode>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionFsErrorCode"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionFsErrorCode"/>.</param>
    [JsonConstructor]
    public SessionFsErrorCode(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionFsErrorCode"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The requested path does not exist.</summary>
    public static SessionFsErrorCode ENOENT { get; } = new("ENOENT");

    /// <summary>The filesystem operation failed for an unspecified reason.</summary>
    public static SessionFsErrorCode UNKNOWN { get; } = new("UNKNOWN");

    /// <summary>Returns a value indicating whether two <see cref="SessionFsErrorCode"/> instances are equivalent.</summary>
    public static bool operator ==(SessionFsErrorCode left, SessionFsErrorCode right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionFsErrorCode"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionFsErrorCode left, SessionFsErrorCode right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionFsErrorCode other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionFsErrorCode other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionFsErrorCode}"/> for serializing <see cref="SessionFsErrorCode"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionFsErrorCode>
    {
        /// <inheritdoc />
        public override SessionFsErrorCode Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionFsErrorCode value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionFsErrorCode));
        }
    }
}


/// <summary>Entry type.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionFsReaddirWithTypesEntryType : IEquatable<SessionFsReaddirWithTypesEntryType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionFsReaddirWithTypesEntryType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionFsReaddirWithTypesEntryType"/>.</param>
    [JsonConstructor]
    public SessionFsReaddirWithTypesEntryType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionFsReaddirWithTypesEntryType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The entry is a file.</summary>
    public static SessionFsReaddirWithTypesEntryType File { get; } = new("file");

    /// <summary>The entry is a directory.</summary>
    public static SessionFsReaddirWithTypesEntryType Directory { get; } = new("directory");

    /// <summary>Returns a value indicating whether two <see cref="SessionFsReaddirWithTypesEntryType"/> instances are equivalent.</summary>
    public static bool operator ==(SessionFsReaddirWithTypesEntryType left, SessionFsReaddirWithTypesEntryType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionFsReaddirWithTypesEntryType"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionFsReaddirWithTypesEntryType left, SessionFsReaddirWithTypesEntryType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionFsReaddirWithTypesEntryType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionFsReaddirWithTypesEntryType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionFsReaddirWithTypesEntryType}"/> for serializing <see cref="SessionFsReaddirWithTypesEntryType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionFsReaddirWithTypesEntryType>
    {
        /// <inheritdoc />
        public override SessionFsReaddirWithTypesEntryType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionFsReaddirWithTypesEntryType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionFsReaddirWithTypesEntryType));
        }
    }
}


/// <summary>How to execute the query: 'exec' for DDL/multi-statement (no results), 'query' for SELECT (returns rows), 'run' for INSERT/UPDATE/DELETE (returns rowsAffected).</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionFsSqliteQueryType : IEquatable<SessionFsSqliteQueryType>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionFsSqliteQueryType"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionFsSqliteQueryType"/>.</param>
    [JsonConstructor]
    public SessionFsSqliteQueryType(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionFsSqliteQueryType"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Execute DDL or multi-statement SQL without returning rows.</summary>
    public static SessionFsSqliteQueryType Exec { get; } = new("exec");

    /// <summary>Execute a SELECT-style query and return rows.</summary>
    public static SessionFsSqliteQueryType Query { get; } = new("query");

    /// <summary>Execute INSERT, UPDATE, or DELETE SQL and return affected-row metadata.</summary>
    public static SessionFsSqliteQueryType Run { get; } = new("run");

    /// <summary>Returns a value indicating whether two <see cref="SessionFsSqliteQueryType"/> instances are equivalent.</summary>
    public static bool operator ==(SessionFsSqliteQueryType left, SessionFsSqliteQueryType right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionFsSqliteQueryType"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionFsSqliteQueryType left, SessionFsSqliteQueryType right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionFsSqliteQueryType other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionFsSqliteQueryType other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionFsSqliteQueryType}"/> for serializing <see cref="SessionFsSqliteQueryType"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionFsSqliteQueryType>
    {
        /// <inheritdoc />
        public override SessionFsSqliteQueryType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionFsSqliteQueryType value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionFsSqliteQueryType));
        }
    }
}


/// <summary>SQLite transaction failure classification.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct SessionFsSqliteTransactionErrorClass : IEquatable<SessionFsSqliteTransactionErrorClass>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="SessionFsSqliteTransactionErrorClass"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="SessionFsSqliteTransactionErrorClass"/>.</param>
    [JsonConstructor]
    public SessionFsSqliteTransactionErrorClass(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="SessionFsSqliteTransactionErrorClass"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>SQLite reported BUSY or LOCKED before commit; the transaction was rolled back and may be retried.</summary>
    public static SessionFsSqliteTransactionErrorClass BusyOrLocked { get; } = new("busyOrLocked");

    /// <summary>The statement, database, or provider failed definitively and must not be retried automatically.</summary>
    public static SessionFsSqliteTransactionErrorClass Fatal { get; } = new("fatal");

    /// <summary>The transport failed after the provider may have committed; retrying could duplicate effects.</summary>
    public static SessionFsSqliteTransactionErrorClass PostCommitAmbiguous { get; } = new("postCommitAmbiguous");

    /// <summary>Returns a value indicating whether two <see cref="SessionFsSqliteTransactionErrorClass"/> instances are equivalent.</summary>
    public static bool operator ==(SessionFsSqliteTransactionErrorClass left, SessionFsSqliteTransactionErrorClass right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="SessionFsSqliteTransactionErrorClass"/> instances are not equivalent.</summary>
    public static bool operator !=(SessionFsSqliteTransactionErrorClass left, SessionFsSqliteTransactionErrorClass right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is SessionFsSqliteTransactionErrorClass other && Equals(other);

    /// <inheritdoc />
    public bool Equals(SessionFsSqliteTransactionErrorClass other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{SessionFsSqliteTransactionErrorClass}"/> for serializing <see cref="SessionFsSqliteTransactionErrorClass"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<SessionFsSqliteTransactionErrorClass>
    {
        /// <inheritdoc />
        public override SessionFsSqliteTransactionErrorClass Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, SessionFsSqliteTransactionErrorClass value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(SessionFsSqliteTransactionErrorClass));
        }
    }
}


/// <summary>Transport the runtime would otherwise use for this request. `http` (the default when absent) covers plain HTTP and SSE responses; `websocket` indicates a full-duplex message channel where each body chunk maps to one WebSocket message and the `binary` flag distinguishes text from binary frames. The SDK consumer uses this to decide whether to service the request with an HTTP client or a WebSocket client. It is the one piece of request metadata the consumer cannot reliably infer from the URL or headers alone.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct LlmInferenceHttpRequestStartTransport : IEquatable<LlmInferenceHttpRequestStartTransport>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="LlmInferenceHttpRequestStartTransport"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="LlmInferenceHttpRequestStartTransport"/>.</param>
    [JsonConstructor]
    public LlmInferenceHttpRequestStartTransport(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="LlmInferenceHttpRequestStartTransport"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>Plain HTTP or SSE response. Each body chunk is an opaque byte range; the response is a status line, headers, and a (possibly streamed) body.</summary>
    public static LlmInferenceHttpRequestStartTransport Http { get; } = new("http");

    /// <summary>Full-duplex WebSocket channel. Each body chunk maps to exactly one WebSocket message and the `binary` flag distinguishes text from binary frames; request and response chunks flow concurrently.</summary>
    public static LlmInferenceHttpRequestStartTransport Websocket { get; } = new("websocket");

    /// <summary>Returns a value indicating whether two <see cref="LlmInferenceHttpRequestStartTransport"/> instances are equivalent.</summary>
    public static bool operator ==(LlmInferenceHttpRequestStartTransport left, LlmInferenceHttpRequestStartTransport right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="LlmInferenceHttpRequestStartTransport"/> instances are not equivalent.</summary>
    public static bool operator !=(LlmInferenceHttpRequestStartTransport left, LlmInferenceHttpRequestStartTransport right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is LlmInferenceHttpRequestStartTransport other && Equals(other);

    /// <inheritdoc />
    public bool Equals(LlmInferenceHttpRequestStartTransport other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{LlmInferenceHttpRequestStartTransport}"/> for serializing <see cref="LlmInferenceHttpRequestStartTransport"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<LlmInferenceHttpRequestStartTransport>
    {
        /// <inheritdoc />
        public override LlmInferenceHttpRequestStartTransport Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, LlmInferenceHttpRequestStartTransport value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(LlmInferenceHttpRequestStartTransport));
        }
    }
}


/// <summary>Why the runtime is requesting a GitHub credential.</summary>
[Experimental(Diagnostics.Experimental)]
[JsonConverter(typeof(Converter))]
[DebuggerDisplay("{Value,nq}")]
public readonly struct GitHubTokenAcquireReason : IEquatable<GitHubTokenAcquireReason>
{
    private readonly string? _value;

    /// <summary>Initializes a new instance of the <see cref="GitHubTokenAcquireReason"/> struct.</summary>
    /// <param name="value">The value to associate with this <see cref="GitHubTokenAcquireReason"/>.</param>
    [JsonConstructor]
    public GitHubTokenAcquireReason(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        _value = value;
    }

    /// <summary>Gets the value associated with this <see cref="GitHubTokenAcquireReason"/>.</summary>
    public string Value => _value ?? string.Empty;

    /// <summary>The runtime is acquiring the registration's first credential.</summary>
    public static GitHubTokenAcquireReason Initial { get; } = new("initial");

    /// <summary>The runtime is replacing a credential that is approaching expiry.</summary>
    public static GitHubTokenAcquireReason Refresh { get; } = new("refresh");

    /// <summary>Returns a value indicating whether two <see cref="GitHubTokenAcquireReason"/> instances are equivalent.</summary>
    public static bool operator ==(GitHubTokenAcquireReason left, GitHubTokenAcquireReason right) => left.Equals(right);

    /// <summary>Returns a value indicating whether two <see cref="GitHubTokenAcquireReason"/> instances are not equivalent.</summary>
    public static bool operator !=(GitHubTokenAcquireReason left, GitHubTokenAcquireReason right) => !(left == right);

    /// <inheritdoc />
    public override bool Equals(object? obj) => obj is GitHubTokenAcquireReason other && Equals(other);

    /// <inheritdoc />
    public bool Equals(GitHubTokenAcquireReason other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);

    /// <inheritdoc />
    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Value);

    /// <inheritdoc />
    public override string ToString() => Value;

    /// <summary>Provides a <see cref="JsonConverter{GitHubTokenAcquireReason}"/> for serializing <see cref="GitHubTokenAcquireReason"/> instances.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed class Converter : JsonConverter<GitHubTokenAcquireReason>
    {
        /// <inheritdoc />
        public override GitHubTokenAcquireReason Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return new(GeneratedStringEnumJson.ReadValue(ref reader, typeToConvert));
        }

        /// <inheritdoc />
        public override void Write(Utf8JsonWriter writer, GitHubTokenAcquireReason value, JsonSerializerOptions options)
        {
            GeneratedStringEnumJson.WriteValue(writer, value.Value, typeof(GitHubTokenAcquireReason));
        }
    }
}


/// <summary>Provides server-scoped RPC methods (no session required).</summary>
public sealed class ServerRpc
{
    private readonly JsonRpc _rpc;

    internal ServerRpc(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Checks server responsiveness and returns protocol information.</summary>
    /// <param name="message">Optional message to echo back.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Server liveness response, including the echoed message, current server timestamp, and protocol version.</returns>
    [Experimental(Diagnostics.Experimental)]
    public async Task<PingResult> PingAsync(string? message = null, CancellationToken cancellationToken = default)
    {
        var request = new PingRequest { Message = message };
        return await CopilotClient.InvokeRpcAsync<PingResult>(_rpc, "ping", [request], cancellationToken);
    }

    /// <summary>Performs the SDK server connection handshake and validates the optional connection token. Marked internal because this is JSON-RPC transport plumbing invoked automatically by an SDK client's own `connect()` wrapper, not a user-facing method. Stays internal as long as the SDK client owns the handshake; would only become public if the SDK ever exposed the raw schema surface to consumers without a connection wrapper.</summary>
    /// <param name="enableGitHubTelemetryForwarding">Opt this connection in to GitHub telemetry forwarding for its lifetime. When set, the runtime forwards every internal telemetry event it emits — across all sessions, plus sessionless events — to this connection over the `gitHubTelemetry.event` notification. Regular events are also written to the runtime's normal GitHub/CTS path (dual-write); host-only compatibility events are forward-only and intentionally skip that path. Intended for first-party hosts that re-emit the events into their own telemetry stores. Both unrestricted and restricted events are forwarded, each tagged with a `restricted` discriminator; a backstop drops restricted events when restricted telemetry is disabled — using the process-global gate for ordinary events and an explicit session-scoped decision for host-only events.</param>
    /// <param name="clientInfo">Identity of the integrating host. Optional; omit it to keep the default attribution.</param>
    /// <param name="supportedTaskKinds">Task kinds this connection can decode when observing session tasks. Omit to retain agent and shell compatibility.</param>
    /// <param name="token">Connection token; required when the server was started with COPILOT_CONNECTION_TOKEN.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Handshake result reporting the server's protocol version and package version on success.</returns>
    [Experimental(Diagnostics.Experimental)]
    internal async Task<ConnectResult> ConnectAsync(bool? enableGitHubTelemetryForwarding = null, ConnectClientInfo? clientInfo = null, IList<TaskKind>? supportedTaskKinds = null, string? token = null, CancellationToken cancellationToken = default)
    {
        var request = new ConnectRequest { EnableGitHubTelemetryForwarding = enableGitHubTelemetryForwarding, ClientInfo = clientInfo, SupportedTaskKinds = supportedTaskKinds, Token = token };
        return await CopilotClient.InvokeRpcAsync<ConnectResult>(_rpc, "connect", [request], cancellationToken);
    }

    /// <summary>Registers the calling SDK client as the per-entrypoint extension launch provider. Call before creating any sessions. When omitted, the runtime uses its built-in extension launcher.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    [Experimental(Diagnostics.Experimental)]
    public async Task RegisterExtensionLaunchProviderAsync(CancellationToken cancellationToken = default)
    {
        await CopilotClient.InvokeRpcAsync(_rpc, "registerExtensionLaunchProvider", [], cancellationToken);
    }

    /// <summary>Hooks APIs.</summary>
    public ServerHooksApi Hooks =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Models APIs.</summary>
    public ServerModelsApi Models =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Tools APIs.</summary>
    public ServerToolsApi Tools =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Account APIs.</summary>
    public ServerAccountApi Account =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Secrets APIs.</summary>
    public ServerSecretsApi Secrets =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Mcp APIs.</summary>
    public ServerMcpApi Mcp =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Extensions APIs.</summary>
    public ServerExtensionsApi Extensions =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Catalog APIs.</summary>
    public ServerCatalogApi Catalog =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Plugins APIs.</summary>
    public ServerPluginsApi Plugins =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Skills APIs.</summary>
    public ServerSkillsApi Skills =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Agents APIs.</summary>
    public ServerAgentsApi Agents =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Instructions APIs.</summary>
    public ServerInstructionsApi Instructions =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Commands APIs.</summary>
    public ServerCommandsApi Commands =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>User APIs.</summary>
    public ServerUserApi User =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>ManagedSettings APIs.</summary>
    public ServerManagedSettingsApi ManagedSettings =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Runtime APIs.</summary>
    public ServerRuntimeApi Runtime =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>SessionFs APIs.</summary>
    public ServerSessionFsApi SessionFs =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>LlmInference APIs.</summary>
    public ServerLlmInferenceApi LlmInference =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Sessions APIs.</summary>
    public ServerSessionsApi Sessions =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>AgentRegistry APIs.</summary>
    public ServerAgentRegistryApi AgentRegistry =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;
}

/// <summary>Provides server-scoped Hooks APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerHooksApi
{
    private readonly JsonRpc _rpc;

    internal ServerHooksApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Discovers hook actions enabled under server-side discovery settings from user, repository, plugin, and managed-policy sources.</summary>
    /// <param name="projectPaths">Optional project directory paths whose trusted repository and project-expanded plugin hooks should be discovered. When omitted or empty, user, managed-policy, and globally enabled installed or explicit plugin hooks are returned without project expansion.</param>
    /// <param name="excludeHostHooks">When true, omit host-owned user and plugin hook rows and their diagnostics. Managed-policy hooks and trusted repository hooks remain visible, and host disabledHooks still contribute to each remaining row's effective enabled state. This filters sources rather than simulating a host with no settings.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Server-discovered hook actions and partial-load diagnostics from user, repository, plugin, and managed-policy sources. Concrete sessions may include additional session-specific hook sources.</returns>
    public async Task<HooksDiscoverResult> DiscoverAsync(IList<string>? projectPaths = null, bool? excludeHostHooks = null, CancellationToken cancellationToken = default)
    {
        var request = new HooksDiscoverRequest { ProjectPaths = projectPaths, ExcludeHostHooks = excludeHostHooks };
        return await CopilotClient.InvokeRpcAsync<HooksDiscoverResult>(_rpc, "hooks.discover", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Models APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerModelsApi
{
    private readonly JsonRpc _rpc;

    internal ServerModelsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Lists Copilot models available to the authenticated user.</summary>
    /// <param name="selectionId">Opaque account identifier returned by `account.getAllUsers`. When omitted, the current account is used.</param>
    /// <param name="gitHubToken">GitHub token accepted for compatibility with existing SDK clients. When provided, resolves this token instead of using the current account.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>List of Copilot models available to the resolved user, including capabilities and billing metadata.</returns>
    public async Task<ModelList> ListAsync(string? selectionId = null, string? gitHubToken = null, CancellationToken cancellationToken = default)
    {
        var request = new ModelsListRequest { SelectionId = selectionId, GitHubToken = gitHubToken };
        return await CopilotClient.InvokeRpcAsync<ModelList>(_rpc, "models.list", [request], cancellationToken);
    }

    /// <summary>Returns the running runtime's complete catalog of well-known built-in model IDs without authentication or network access.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The running runtime's complete catalog of well-known built-in model IDs, including supported models and additional IDs with built-in metadata.</returns>
    public async Task<BuiltInModelCatalog> GetBuiltInCatalogAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<BuiltInModelCatalog>(_rpc, "models.getBuiltInCatalog", [], cancellationToken);
    }
}

/// <summary>Provides server-scoped Tools APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerToolsApi
{
    private readonly JsonRpc _rpc;

    internal ServerToolsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Lists built-in tools available for a model.</summary>
    /// <param name="model">Optional model ID — when provided, the returned tool list reflects model-specific overrides.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Built-in tools available for the requested model, with their parameters and instructions.</returns>
    public async Task<ToolList> ListAsync(string? model = null, CancellationToken cancellationToken = default)
    {
        var request = new ToolsListRequest { Model = model };
        return await CopilotClient.InvokeRpcAsync<ToolList>(_rpc, "tools.list", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Account APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerAccountApi
{
    private readonly JsonRpc _rpc;

    internal ServerAccountApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Gets Copilot quota usage for the current or opaquely selected authenticated user.</summary>
    /// <param name="selectionId">Opaque account identifier returned by `account.getAllUsers`. When omitted, the current account is used.</param>
    /// <param name="gitHubToken">GitHub token accepted for compatibility with existing SDK clients. When provided, resolves this token instead of using the current account.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Quota usage snapshots for the resolved user, keyed by quota type.</returns>
    public async Task<AccountGetQuotaResult> GetQuotaAsync(string? selectionId = null, string? gitHubToken = null, CancellationToken cancellationToken = default)
    {
        var request = new AccountGetQuotaRequest { SelectionId = selectionId, GitHubToken = gitHubToken };
        return await CopilotClient.InvokeRpcAsync<AccountGetQuotaResult>(_rpc, "account.getQuota", [request], cancellationToken);
    }

    /// <summary>Gets the currently active authentication credentials from the global auth manager.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current authentication state.</returns>
    public async Task<AccountGetCurrentAuthResult> GetCurrentAuthAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<AccountGetCurrentAuthResult>(_rpc, "account.getCurrentAuth", [], cancellationToken);
    }

    /// <summary>Gets all authenticated users available for account switching.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>List of all authenticated users.</returns>
    public async Task<IList<AccountAllUsers>> GetAllUsersAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<IList<AccountAllUsers>>(_rpc, "account.getAllUsers", [], cancellationToken);
    }

    /// <summary>Validates and stores authentication credentials. When login is omitted, resolves the authenticated user from the token before persistence.</summary>
    /// <param name="host">GitHub host URL.</param>
    /// <param name="token">GitHub authentication token.</param>
    /// <param name="login">User login/username. When omitted, the runtime validates the token and resolves the login from GitHub.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of a successful login; throws on failure.</returns>
    public async Task<AccountLoginResult> LoginAsync(string host, string token, string? login = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(host);
        ArgumentNullException.ThrowIfNull(token);

        var request = new AccountLoginRequest { Host = host, Token = token, Login = login };
        return await CopilotClient.InvokeRpcAsync<AccountLoginResult>(_rpc, "account.login", [request], cancellationToken);
    }

    /// <summary>Removes user authentication from keychain and persisted state.</summary>
    /// <param name="selectionId">Opaque account identifier returned by `account.getAllUsers`.</param>
    /// <param name="authInfo">Authentication information for the user to log out.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Logout result indicating if more users remain.</returns>
    public async Task<AccountLogoutResult> LogoutAsync(string? selectionId = null, AuthInfo? authInfo = null, CancellationToken cancellationToken = default)
    {
        var request = new AccountLogoutRequest { SelectionId = selectionId, AuthInfo = authInfo };
        return await CopilotClient.InvokeRpcAsync<AccountLogoutResult>(_rpc, "account.logout", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Secrets APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerSecretsApi
{
    private readonly JsonRpc _rpc;

    internal ServerSecretsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Registers secret values for redaction in session logs and exports. The SDK calls this to inject dynamically generated secret values (e.g., OIDC tokens).</summary>
    /// <param name="values">Raw secret values to register for redaction.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Confirmation that the secret values were registered.</returns>
    public async Task<SecretsAddFilterValuesResult> AddFilterValuesAsync(IList<string> values, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(values);

        var request = new SecretsAddFilterValuesRequest { Values = values };
        return await CopilotClient.InvokeRpcAsync<SecretsAddFilterValuesResult>(_rpc, "secrets.addFilterValues", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Mcp APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerMcpApi
{
    private readonly JsonRpc _rpc;

    internal ServerMcpApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Discovers MCP servers from user, workspace, plugin, and builtin sources.</summary>
    /// <param name="workingDirectory">Working directory used as context for discovery (e.g., plugin resolution).</param>
    /// <param name="includeEffectiveSource">Whether to include canonical effectiveSource metadata for each discovered server. Callers must opt in so protocol-3 clients retain the legacy closed response shape.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>MCP servers discovered from user, workspace, plugin, and built-in sources.</returns>
    public async Task<McpDiscoverResult> DiscoverAsync(string? workingDirectory = null, bool? includeEffectiveSource = null, CancellationToken cancellationToken = default)
    {
        var request = new McpDiscoverRequest { WorkingDirectory = workingDirectory, IncludeEffectiveSource = includeEffectiveSource };
        return await CopilotClient.InvokeRpcAsync<McpDiscoverResult>(_rpc, "mcp.discover", [request], cancellationToken);
    }

    /// <summary>Requests a side-effect-free MCP install plan from a catalog candidate handle or a caller-supplied card. This host-implemented server method is available through SDK/TUI hosts; standalone and C-ABI runtimes whose host does not implement server-method dispatch return JSON-RPC MethodNotFound. A runtime with planning available returns a normalised plan and opaque single-use plan handle; a runtime without it returns the typed planning-unavailable result. A completed plan reports resource identity, provenance, eligible transport choices, the user-scope target, required typed values and secret placeholders, the policy result, the configuration changes installing would make, and whether a reload would be needed. Planning never writes configuration, stores a secret, or reloads MCP servers, so abandoning a plan needs no call and leaves nothing behind.</summary>
    /// <param name="contract">Protocol version and capabilities the caller requires.</param>
    /// <param name="source">What to plan: either a candidate handle from a previous search, or a card supplied directly.</param>
    /// <param name="scope">Configuration scope the plan targets. Defaults to user scope when omitted.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of an mcp.planInstall call: either a normalised plan, or one typed refusal. Nothing is written in either case.</returns>
    public async Task<McpPlanInstallResult> PlanInstallAsync(CatalogClientContract contract, McpPlanInstallSource source, McpPlanScope? scope = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(contract);
        ArgumentNullException.ThrowIfNull(source);

        var request = new McpPlanInstallRequest { Contract = contract, Source = source, Scope = scope };
        return await CopilotClient.InvokeRpcAsync<McpPlanInstallResult>(_rpc, "mcp.planInstall", [request], cancellationToken);
    }

    /// <summary>Config APIs.</summary>
    public ServerMcpConfigApi Config =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;
}

/// <summary>Provides server-scoped McpConfig APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerMcpConfigApi
{
    private readonly JsonRpc _rpc;

    internal ServerMcpConfigApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Lists MCP servers from user configuration.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>User-configured MCP servers, keyed by server name.</returns>
    public async Task<McpConfigList> ListAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<McpConfigList>(_rpc, "mcp.config.list", [], cancellationToken);
    }

    /// <summary>Adds an MCP server to user configuration.</summary>
    /// <param name="name">Unique name for the MCP server.</param>
    /// <param name="config">MCP server configuration (stdio process or remote HTTP/SSE).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task AddAsync(string name, object config, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        ArgumentNullException.ThrowIfNull(config);

        var request = new McpConfigAddRequest { Name = name, Config = CopilotClient.ToJsonElementForWire(config)!.Value };
        await CopilotClient.InvokeRpcAsync(_rpc, "mcp.config.add", [request], cancellationToken);
    }

    /// <summary>Updates an MCP server in user configuration.</summary>
    /// <param name="name">Name of the MCP server to update.</param>
    /// <param name="config">MCP server configuration (stdio process or remote HTTP/SSE).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task UpdateAsync(string name, object config, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        ArgumentNullException.ThrowIfNull(config);

        var request = new McpConfigUpdateRequest { Name = name, Config = CopilotClient.ToJsonElementForWire(config)!.Value };
        await CopilotClient.InvokeRpcAsync(_rpc, "mcp.config.update", [request], cancellationToken);
    }

    /// <summary>Removes an MCP server from user configuration.</summary>
    /// <param name="name">Name of the MCP server to remove.</param>
    /// <param name="authClientIdMetadataUrl">OAuth Client ID Metadata Document URL whose persisted credentials should also be removed.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task RemoveAsync(string name, string? authClientIdMetadataUrl = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);

        var request = new McpConfigRemoveRequest { Name = name, AuthClientIdMetadataUrl = authClientIdMetadataUrl };
        await CopilotClient.InvokeRpcAsync(_rpc, "mcp.config.remove", [request], cancellationToken);
    }

    /// <summary>Enables MCP servers in user configuration for new sessions.</summary>
    /// <param name="names">Names of MCP servers to enable. Each server is removed from the persisted disabled list so new sessions spawn it. Unknown or already-enabled names are ignored.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task EnableAsync(IList<string> names, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(names);

        var request = new McpConfigEnableRequest { Names = names };
        await CopilotClient.InvokeRpcAsync(_rpc, "mcp.config.enable", [request], cancellationToken);
    }

    /// <summary>Disables MCP servers in user configuration for new sessions.</summary>
    /// <param name="names">Names of MCP servers to disable. Each server is added to the persisted disabled list so new sessions skip it. Already-disabled names are ignored. Active sessions keep their current connections until they end.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DisableAsync(IList<string> names, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(names);

        var request = new McpConfigDisableRequest { Names = names };
        await CopilotClient.InvokeRpcAsync(_rpc, "mcp.config.disable", [request], cancellationToken);
    }

    /// <summary>Drops this runtime process's in-memory MCP server-definition cache so the next MCP config read observes disk.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ReloadAsync(CancellationToken cancellationToken = default)
    {
        await CopilotClient.InvokeRpcAsync(_rpc, "mcp.config.reload", [], cancellationToken);
    }
}

/// <summary>Provides server-scoped Extensions APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerExtensionsApi
{
    private readonly JsonRpc _rpc;

    internal ServerExtensionsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Discovers user and enabled installed-plugin extensions from persisted Copilot home state, including enablement preferences. Launch-scoped additional plugins are not included.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Extensions discovered from persisted Copilot home state and their effective loading mode. Launch-scoped additional plugins are not included.</returns>
    public async Task<DiscoveredExtensions> DiscoverAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<DiscoveredExtensions>(_rpc, "extensions.discover", [], cancellationToken);
    }

    /// <summary>Persistently enables extension IDs for future sessions. Active sessions are unchanged; use session.extensions.enable to update them.</summary>
    /// <param name="ids">Source-qualified user or plugin extension IDs to enable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task EnableAsync(IList<string> ids, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(ids);

        var request = new DiscoveredExtensionsEnableRequest { Ids = ids };
        await CopilotClient.InvokeRpcAsync(_rpc, "extensions.enable", [request], cancellationToken);
    }

    /// <summary>Persistently disables extension IDs for future sessions. Active sessions are unchanged; use session.extensions.disable to update them.</summary>
    /// <param name="ids">Source-qualified user or plugin extension IDs to disable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DisableAsync(IList<string> ids, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(ids);

        var request = new DiscoveredExtensionsDisableRequest { Ids = ids };
        await CopilotClient.InvokeRpcAsync(_rpc, "extensions.disable", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Catalog APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerCatalogApi
{
    private readonly JsonRpc _rpc;

    internal ServerCatalogApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Requests a bounded catalog search. This host-implemented server method is available through SDK/TUI hosts; standalone and C-ABI runtimes whose host does not implement server-method dispatch return JSON-RPC MethodNotFound. A runtime with search available returns inert candidate summaries, each with an opaque single-use handle scoped to this runtime instance; a runtime without it returns the typed search-unavailable result. Public authorities may be searched anonymously, while an authority that requires credentials yields the typed authentication-required result. All returned text, URLs, and package metadata are untrusted external data and can never trigger instructions, tools, or installation. Read-only: nothing is installed, configured, or persisted.</summary>
    /// <param name="contract">Protocol version and capabilities the caller requires.</param>
    /// <param name="query">Free-text search query. Persisted as tool input for session continuity, but omitted from telemetry.</param>
    /// <param name="limit">Maximum number of candidates to return. Defaults to 10 when omitted.</param>
    /// <param name="kinds">Restrict results to these candidate kinds. When omitted, every kind the runtime supports is searched.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of a catalog.search call: either bounded inert candidates, or one typed refusal. Never a partial success.</returns>
    public async Task<CatalogSearchResult> SearchAsync(CatalogClientContract contract, string query, int? limit = null, IList<CatalogCandidateKind>? kinds = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(contract);
        ArgumentNullException.ThrowIfNull(query);

        var request = new CatalogSearchRequest { Contract = contract, Query = query, Limit = limit, Kinds = kinds };
        return await CopilotClient.InvokeRpcAsync<CatalogSearchResult>(_rpc, "catalog.search", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Plugins APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerPluginsApi
{
    private readonly JsonRpc _rpc;

    internal ServerPluginsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Lists plugins installed in user/global state.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Plugins installed in user/global state.</returns>
    public async Task<PluginListResult> ListAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<PluginListResult>(_rpc, "plugins.list", [], cancellationToken);
    }

    /// <summary>Installs a plugin from a marketplace, GitHub repo, URL, or local path.</summary>
    /// <param name="source">Plugin install spec. Accepts the same forms as the CLI: "plugin@marketplace" (marketplace install), "owner/repo" or "owner/repo:subpath" (GitHub direct), an http/https/ssh URL, or a local path. Direct (non-marketplace) installs are deprecated and will produce a deprecationWarning in the result.</param>
    /// <param name="workingDirectory">Working directory used to resolve relative local paths in `source`. Defaults to the server's current working directory.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of installing a plugin.</returns>
    public async Task<PluginInstallResult> InstallAsync(string source, string? workingDirectory = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(source);

        var request = new PluginsInstallRequest { Source = source, WorkingDirectory = workingDirectory };
        return await CopilotClient.InvokeRpcAsync<PluginInstallResult>(_rpc, "plugins.install", [request], cancellationToken);
    }

    /// <summary>Uninstalls an installed plugin.</summary>
    /// <param name="name">Plugin name or "plugin@marketplace" spec to uninstall. When ambiguous, prefer the fully-qualified spec.</param>
    /// <param name="directSourceId">Stable source identity for a direct (non-marketplace) install. Disambiguates uninstall when multiple installed plugins share the same name.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task UninstallAsync(string name, string? directSourceId = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);

        var request = new PluginsUninstallRequest { Name = name, DirectSourceId = directSourceId };
        await CopilotClient.InvokeRpcAsync(_rpc, "plugins.uninstall", [request], cancellationToken);
    }

    /// <summary>Updates an installed plugin to its latest published version.</summary>
    /// <param name="name">Plugin name or "plugin@marketplace" spec to update.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of updating a single plugin.</returns>
    public async Task<PluginUpdateResult> UpdateAsync(string name, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);

        var request = new PluginsUpdateRequest { Name = name };
        return await CopilotClient.InvokeRpcAsync<PluginUpdateResult>(_rpc, "plugins.update", [request], cancellationToken);
    }

    /// <summary>Updates every installed plugin to its latest published version.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of updating all installed plugins.</returns>
    public async Task<PluginUpdateAllResult> UpdateAllAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<PluginUpdateAllResult>(_rpc, "plugins.updateAll", [], cancellationToken);
    }

    /// <summary>Enables installed plugins for new sessions.</summary>
    /// <param name="names">Plugin names or "plugin@marketplace" specs to enable. Unknown names are ignored. Non-marketplace direct installs are always enabled and cannot be toggled via this API.</param>
    /// <param name="workingDirectory">Working directory whose repository `enabledPlugins` overlay decides whether this mutation is repository-controlled. Hosts that serve sessions across several repositories (the SDK server) should pass the session's directory; otherwise the guard is evaluated against the server process's own working directory, which may belong to a different repository. Defaults to the server's current working directory.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task EnableAsync(IList<string> names, string? workingDirectory = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(names);

        var request = new PluginsEnableRequest { Names = names, WorkingDirectory = workingDirectory };
        await CopilotClient.InvokeRpcAsync(_rpc, "plugins.enable", [request], cancellationToken);
    }

    /// <summary>Disables installed plugins for new sessions.</summary>
    /// <param name="names">Plugin names or "plugin@marketplace" specs to disable. Unknown names are ignored. Non-marketplace direct installs cannot be disabled via this API; uninstall them instead. Plugin-owned MCP servers are stopped in active sessions immediately; other plugin contributions remain available until each session reloads plugins.</param>
    /// <param name="workingDirectory">Working directory whose repository `enabledPlugins` overlay decides whether this mutation is repository-controlled. Hosts that serve sessions across several repositories (the SDK server) should pass the session's directory; otherwise the guard is evaluated against the server process's own working directory, which may belong to a different repository. Defaults to the server's current working directory.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DisableAsync(IList<string> names, string? workingDirectory = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(names);

        var request = new PluginsDisableRequest { Names = names, WorkingDirectory = workingDirectory };
        await CopilotClient.InvokeRpcAsync(_rpc, "plugins.disable", [request], cancellationToken);
    }

    /// <summary>Builtin APIs.</summary>
    public ServerPluginsBuiltinApi Builtin =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;

    /// <summary>Marketplaces APIs.</summary>
    public ServerPluginsMarketplacesApi Marketplaces =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;
}

/// <summary>Provides server-scoped PluginsBuiltin APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerPluginsBuiltinApi
{
    private readonly JsonRpc _rpc;

    internal ServerPluginsBuiltinApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Replaces this server's trusted built-in plugin directories while no sessions are active.</summary>
    /// <param name="paths">Complete replacement set of trusted built-in plugin directories. Every entry must be an absolute local filesystem path no longer than 4096 characters.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetAsync(IList<string> paths, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(paths);

        var request = new PluginsBuiltinSetRequest { Paths = paths };
        await CopilotClient.InvokeRpcAsync(_rpc, "plugins.builtin.set", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped PluginsMarketplaces APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerPluginsMarketplacesApi
{
    private readonly JsonRpc _rpc;

    internal ServerPluginsMarketplacesApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Lists all registered marketplaces (defaults + user-added).</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>All registered marketplaces, including built-in defaults.</returns>
    public async Task<MarketplaceListResult> ListAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<MarketplaceListResult>(_rpc, "plugins.marketplaces.list", [], cancellationToken);
    }

    /// <summary>Registers a new marketplace from a source (owner/repo, URL, or local path).</summary>
    /// <param name="source">Marketplace source. Accepts the same forms as the CLI: "owner/repo" or "owner/repo#ref" (GitHub), an http/https/ssh URL (optionally with #ref), a git scp-style URL (user@host:path), or a local path. The marketplace's own name (from its manifest) is used as the registration key.</param>
    /// <param name="workingDirectory">Working directory used to resolve relative local paths in `source`. Defaults to the server's current working directory.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of registering a new marketplace.</returns>
    public async Task<MarketplaceAddResult> AddAsync(string source, string? workingDirectory = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(source);

        var request = new PluginsMarketplacesAddRequest { Source = source, WorkingDirectory = workingDirectory };
        return await CopilotClient.InvokeRpcAsync<MarketplaceAddResult>(_rpc, "plugins.marketplaces.add", [request], cancellationToken);
    }

    /// <summary>Removes a previously-registered marketplace. When the marketplace has dependent plugins and `force` is not set, the marketplace is left intact and the result lists the dependents so the caller can decide whether to retry with `force=true`.</summary>
    /// <param name="name">Marketplace name to remove.</param>
    /// <param name="force">When true, also uninstall every plugin sourced from this marketplace. When false (default), removal is a no-op if any plugin from this marketplace is installed and the dependent plugin names are returned in the result.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of the remove attempt, including dependent-plugin info when applicable.</returns>
    public async Task<MarketplaceRemoveResult> RemoveAsync(string name, bool? force = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);

        var request = new PluginsMarketplacesRemoveRequest { Name = name, Force = force };
        return await CopilotClient.InvokeRpcAsync<MarketplaceRemoveResult>(_rpc, "plugins.marketplaces.remove", [request], cancellationToken);
    }

    /// <summary>Lists plugins advertised by a registered marketplace.</summary>
    /// <param name="name">Marketplace name to browse.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Plugins advertised by the marketplace.</returns>
    public async Task<MarketplaceBrowseResult> BrowseAsync(string name, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);

        var request = new PluginsMarketplacesBrowseRequest { Name = name };
        return await CopilotClient.InvokeRpcAsync<MarketplaceBrowseResult>(_rpc, "plugins.marketplaces.browse", [request], cancellationToken);
    }

    /// <summary>Re-fetches one or all registered marketplace catalogs.</summary>
    /// <param name="name">Marketplace name to refresh. When omitted, every registered marketplace is refreshed.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of refreshing one or more marketplace catalogs.</returns>
    public async Task<MarketplaceRefreshResult> RefreshAsync(string? name = null, CancellationToken cancellationToken = default)
    {
        var request = new PluginsMarketplacesRefreshRequest { Name = name };
        return await CopilotClient.InvokeRpcAsync<MarketplaceRefreshResult>(_rpc, "plugins.marketplaces.refresh", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Skills APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerSkillsApi
{
    private readonly JsonRpc _rpc;

    internal ServerSkillsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Discovers skills across global and project sources.</summary>
    /// <param name="projectPaths">Optional list of project directory paths to scan for project-scoped skills.</param>
    /// <param name="skillDirectories">Optional list of additional skill directory paths to include.</param>
    /// <param name="excludeHostSkills">When true, omit skills from the host's global sources (personal, custom, plugin, and built-in), returning only project-scoped skills. For multitenant deployments.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Skills discovered across global and project sources.</returns>
    public async Task<ServerSkillList> DiscoverAsync(IList<string>? projectPaths = null, IList<string>? skillDirectories = null, bool? excludeHostSkills = null, CancellationToken cancellationToken = default)
    {
        var request = new SkillsDiscoverRequest { ProjectPaths = projectPaths, SkillDirectories = skillDirectories, ExcludeHostSkills = excludeHostSkills };
        return await CopilotClient.InvokeRpcAsync<ServerSkillList>(_rpc, "skills.discover", [request], cancellationToken);
    }

    /// <summary>Returns the canonical directories where a client may create skills that the runtime will recognize, including ones that do not exist yet. Project directories become active once created.</summary>
    /// <param name="projectPaths">Optional list of project directory paths. When omitted or empty, only personal and custom directories are returned.</param>
    /// <param name="excludeHostSkills">When true, omit the host's personal and custom skill directories, leaving only project directories. For multitenant deployments.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Canonical locations where skills can be created so the runtime will recognize them.</returns>
    public async Task<SkillDiscoveryPathList> GetDiscoveryPathsAsync(IList<string>? projectPaths = null, bool? excludeHostSkills = null, CancellationToken cancellationToken = default)
    {
        var request = new SkillsGetDiscoveryPathsRequest { ProjectPaths = projectPaths, ExcludeHostSkills = excludeHostSkills };
        return await CopilotClient.InvokeRpcAsync<SkillDiscoveryPathList>(_rpc, "skills.getDiscoveryPaths", [request], cancellationToken);
    }

    /// <summary>Config APIs.</summary>
    public ServerSkillsConfigApi Config =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;
}

/// <summary>Provides server-scoped SkillsConfig APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerSkillsConfigApi
{
    private readonly JsonRpc _rpc;

    internal ServerSkillsConfigApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Replaces the global list of disabled skills.</summary>
    /// <param name="disabledSkills">List of skill names to disable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetDisabledSkillsAsync(IList<string> disabledSkills, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(disabledSkills);

        var request = new SkillsConfigSetDisabledSkillsRequest { DisabledSkills = disabledSkills };
        await CopilotClient.InvokeRpcAsync(_rpc, "skills.config.setDisabledSkills", [request], cancellationToken);
    }

    /// <summary>Atomically adds or removes one skill from the disabled list.</summary>
    /// <param name="name">Name of the skill to add to or remove from the disabled list.</param>
    /// <param name="disabled">True to disable the skill, false to enable it.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetSkillDisabledAsync(string name, bool disabled, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);

        var request = new SkillsConfigSetSkillDisabledRequest { Name = name, Disabled = disabled };
        await CopilotClient.InvokeRpcAsync(_rpc, "skills.config.setSkillDisabled", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Agents APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerAgentsApi
{
    private readonly JsonRpc _rpc;

    internal ServerAgentsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Discovers custom agents across user, project, plugin, and remote sources.</summary>
    /// <param name="projectPaths">Optional list of project directory paths to scan for project-scoped agents. When omitted or empty, only user/plugin/remote-independent agents are returned (no project scan).</param>
    /// <param name="excludeHostAgents">When true, omit the host's agents (the user-level agent directory and all plugin agents), leaving only project and remote agents. For multitenant deployments.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Agents discovered across user, project, plugin, and remote sources.</returns>
    public async Task<ServerAgentList> DiscoverAsync(IList<string>? projectPaths = null, bool? excludeHostAgents = null, CancellationToken cancellationToken = default)
    {
        var request = new AgentsDiscoverRequest { ProjectPaths = projectPaths, ExcludeHostAgents = excludeHostAgents };
        return await CopilotClient.InvokeRpcAsync<ServerAgentList>(_rpc, "agents.discover", [request], cancellationToken);
    }

    /// <summary>Returns the canonical directories where a client may create custom agents that the runtime will recognize, including ones that do not exist yet. Project directories become active once created.</summary>
    /// <param name="projectPaths">Optional list of project directory paths. When omitted or empty, only the user-level directory is returned.</param>
    /// <param name="excludeHostAgents">When true, omit the host's user-level agent directory, leaving only project directories. For multitenant deployments (mirrors `discover`'s `excludeHostAgents`).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Canonical locations where custom agents can be created so the runtime will recognize them.</returns>
    public async Task<AgentDiscoveryPathList> GetDiscoveryPathsAsync(IList<string>? projectPaths = null, bool? excludeHostAgents = null, CancellationToken cancellationToken = default)
    {
        var request = new AgentsGetDiscoveryPathsRequest { ProjectPaths = projectPaths, ExcludeHostAgents = excludeHostAgents };
        return await CopilotClient.InvokeRpcAsync<AgentDiscoveryPathList>(_rpc, "agents.getDiscoveryPaths", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Instructions APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerInstructionsApi
{
    private readonly JsonRpc _rpc;

    internal ServerInstructionsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Discovers instruction sources across user, repository, and plugin sources.</summary>
    /// <param name="projectPaths">Optional list of project directory paths to scan for repository/working-directory instruction sources. When omitted or empty, only user-level and plugin instruction sources are returned (no project scan).</param>
    /// <param name="excludeHostInstructions">When true, omit the host's instruction sources (user/home-level files and plugin rules), leaving only repository and working-directory sources. For multitenant deployments.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Instruction sources discovered across user, repository, and plugin sources.</returns>
    public async Task<ServerInstructionSourceList> DiscoverAsync(IList<string>? projectPaths = null, bool? excludeHostInstructions = null, CancellationToken cancellationToken = default)
    {
        var request = new InstructionsDiscoverRequest { ProjectPaths = projectPaths, ExcludeHostInstructions = excludeHostInstructions };
        return await CopilotClient.InvokeRpcAsync<ServerInstructionSourceList>(_rpc, "instructions.discover", [request], cancellationToken);
    }

    /// <summary>Returns the canonical files and directories where a client may create custom instructions that the runtime will recognize, including ones that do not exist yet. Repository targets become active once created.</summary>
    /// <param name="projectPaths">Optional list of project directory paths. When omitted or empty, only the user-level targets are returned.</param>
    /// <param name="excludeHostInstructions">When true, omit the host's user-level instruction targets, leaving only repository targets. For multitenant deployments (mirrors `discover`'s `excludeHostInstructions`).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Canonical files and directories where custom instructions can be created so the runtime will recognize them.</returns>
    public async Task<InstructionDiscoveryPathList> GetDiscoveryPathsAsync(IList<string>? projectPaths = null, bool? excludeHostInstructions = null, CancellationToken cancellationToken = default)
    {
        var request = new InstructionsGetDiscoveryPathsRequest { ProjectPaths = projectPaths, ExcludeHostInstructions = excludeHostInstructions };
        return await CopilotClient.InvokeRpcAsync<InstructionDiscoveryPathList>(_rpc, "instructions.getDiscoveryPaths", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Commands APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerCommandsApi
{
    private readonly JsonRpc _rpc;

    internal ServerCommandsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Lists the well-known built-in slash commands that work as the first message in a new session (e.g. /plan, /env), without requiring an active session. Commands that depend on session state, authentication, or a synced session are omitted.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Slash commands available in the session, after applying any include/exclude filters.</returns>
    public async Task<CommandList> ListAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<CommandList>(_rpc, "commands.list", [], cancellationToken);
    }
}

/// <summary>Provides server-scoped User APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerUserApi
{
    private readonly JsonRpc _rpc;

    internal ServerUserApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Settings APIs.</summary>
    public ServerUserSettingsApi Settings =>
        field ??
        Interlocked.CompareExchange(ref field, new(_rpc), null) ??
        field;
}

/// <summary>Provides server-scoped UserSettings APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerUserSettingsApi
{
    private readonly JsonRpc _rpc;

    internal ServerUserSettingsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Drops this runtime process's in-memory user settings cache so the next settings read observes disk.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ReloadAsync(CancellationToken cancellationToken = default)
    {
        await CopilotClient.InvokeRpcAsync(_rpc, "user.settings.reload", [], cancellationToken);
    }

    /// <summary>Lists every known user setting (settings.json overlaid with the legacy config.json, config.json wins), each with its effective value, its default, and whether it is at the default — so settings the user has never set still appear with their default value. Does not include repository- or enterprise-managed overrides that the runtime layers on top at session time.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Per-key metadata for every known user setting (settings.json overlaid with the legacy config.json, config.json wins), including settings left at their default. Excludes repository- and enterprise-managed overrides.</returns>
    public async Task<UserSettingsGetResult> GetAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<UserSettingsGetResult>(_rpc, "user.settings.get", [], cancellationToken);
    }

    /// <summary>Writes one or more user settings to settings.json, replacing each provided top-level key. A key whose value is null is removed. Returns the keys whose new value is shadowed by a legacy config.json entry (config.json wins on read), which the runtime leaves in place — such writes do not take effect until the legacy value is removed.</summary>
    /// <param name="settings">Partial user settings to write, as a free-form object keyed by setting name.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of writing user settings.</returns>
    public async Task<UserSettingsSetResult> SetAsync(object settings, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(settings);

        var request = new UserSettingsSetRequest { Settings = CopilotClient.ToJsonElementForWire(settings)!.Value };
        return await CopilotClient.InvokeRpcAsync<UserSettingsSetResult>(_rpc, "user.settings.set", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped ManagedSettings APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerManagedSettingsApi
{
    private readonly JsonRpc _rpc;

    internal ServerManagedSettingsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Validated device-managed settings discovered before a session exists.</returns>
    public async Task<ManagedSettingsReadResult> ReadAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<ManagedSettingsReadResult>(_rpc, "managedSettings.read", [], cancellationToken);
    }

    /// <summary>Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `&lt;cacheHome&gt;/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ClearCacheAsync(CancellationToken cancellationToken = default)
    {
        await CopilotClient.InvokeRpcAsync(_rpc, "managedSettings.clearCache", [], cancellationToken);
    }
}

/// <summary>Provides server-scoped Runtime APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerRuntimeApi
{
    private readonly JsonRpc _rpc;

    internal ServerRuntimeApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Gracefully shuts down an SDK-owned runtime. The response is sent only after cleanup completes; callers may then terminate the owned runtime process.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ShutdownAsync(CancellationToken cancellationToken = default)
    {
        await CopilotClient.InvokeRpcAsync(_rpc, "runtime.shutdown", [], cancellationToken);
    }
}

/// <summary>Provides server-scoped SessionFs APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerSessionFsApi
{
    private readonly JsonRpc _rpc;

    internal ServerSessionFsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Registers an SDK client as the session filesystem provider.</summary>
    /// <param name="initialCwd">Initial working directory for sessions.</param>
    /// <param name="sessionStatePath">Path within each session's SessionFs where the runtime stores files for that session.</param>
    /// <param name="conventions">Path conventions used by this filesystem.</param>
    /// <param name="capabilities">Optional capabilities declared by the provider.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the calling client was registered as the session filesystem provider.</returns>
    public async Task<SessionFsSetProviderResult> SetProviderAsync(string initialCwd, string sessionStatePath, SessionFsSetProviderConventions conventions, SessionFsSetProviderCapabilities? capabilities = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(initialCwd);
        ArgumentNullException.ThrowIfNull(sessionStatePath);

        var request = new SessionFsSetProviderRequest { InitialCwd = initialCwd, SessionStatePath = sessionStatePath, Conventions = conventions, Capabilities = capabilities };
        return await CopilotClient.InvokeRpcAsync<SessionFsSetProviderResult>(_rpc, "sessionFs.setProvider", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped LlmInference APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerLlmInferenceApi
{
    private readonly JsonRpc _rpc;

    internal ServerLlmInferenceApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Registers an SDK client as the LLM inference callback provider.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the calling client was registered as the LLM inference provider.</returns>
    public async Task<LlmInferenceSetProviderResult> SetProviderAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<LlmInferenceSetProviderResult>(_rpc, "llmInference.setProvider", [], cancellationToken);
    }

    /// <summary>Delivers the response head (status + headers) for an in-flight request, correlated by the requestId the runtime supplied in httpRequestStart. Must be called exactly once per request before any httpResponseChunk frames.</summary>
    /// <param name="requestId">Matches the requestId from the originating httpRequestStart frame.</param>
    /// <param name="status">HTTP status code.</param>
    /// <param name="headers">HTTP response headers, preserving multiple values per name.</param>
    /// <param name="statusText">Optional HTTP status reason phrase.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the start frame was accepted.</returns>
    public async Task<LlmInferenceHttpResponseStartResult> HttpResponseStartAsync(string requestId, long status, IDictionary<string, IList<string>> headers, string? statusText = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(headers);

        var request = new LlmInferenceHttpResponseStartRequest { RequestId = requestId, Status = status, Headers = headers, StatusText = statusText };
        return await CopilotClient.InvokeRpcAsync<LlmInferenceHttpResponseStartResult>(_rpc, "llmInference.httpResponseStart", [request], cancellationToken);
    }

    /// <summary>Delivers a body byte range (or a terminal transport error) for an in-flight response, correlated by requestId. Set `end` true on the last chunk. When `error` is set the response terminates with a transport-level failure and the runtime raises an APIConnectionError.</summary>
    /// <param name="requestId">Matches the requestId from the originating httpRequestStart frame.</param>
    /// <param name="data">Body byte range. UTF-8 text when `binary` is absent or false; base64-encoded bytes when `binary` is true. May be empty (e.g. when the response body is empty: send a single chunk with empty data and end=true).</param>
    /// <param name="binary">When true, `data` is base64-encoded bytes. When absent or false, `data` is UTF-8 text.</param>
    /// <param name="end">When true, this is the final body chunk for the response. The runtime treats the response body as complete after receiving an end-marked chunk.</param>
    /// <param name="error">Set to terminate the response with a transport-level failure. Implies end-of-stream; any further chunks for this requestId are ignored.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the chunk was accepted.</returns>
    public async Task<LlmInferenceHttpResponseChunkResult> HttpResponseChunkAsync(string requestId, string data, bool? binary = null, bool? end = null, LlmInferenceHttpResponseChunkError? error = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(data);

        var request = new LlmInferenceHttpResponseChunkRequest { RequestId = requestId, Data = data, Binary = binary, End = end, Error = error };
        return await CopilotClient.InvokeRpcAsync<LlmInferenceHttpResponseChunkResult>(_rpc, "llmInference.httpResponseChunk", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped Sessions APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerSessionsApi
{
    private readonly JsonRpc _rpc;

    internal ServerSessionsApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Creates or resumes a local session and returns the opened session ID.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of opening a session.</returns>
    public async Task<SessionOpenResult> OpenAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<SessionOpenResult>(_rpc, "sessions.open", [], cancellationToken);
    }

    /// <summary>Creates a new session by forking persisted history from an existing session.</summary>
    /// <param name="sessionId">Source session ID to fork from.</param>
    /// <param name="toEventId">Optional event ID boundary. When provided, the fork includes only events before this ID (exclusive). When omitted, all events are included.</param>
    /// <param name="name">Optional friendly name to assign to the forked session.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Identifier and optional friendly name assigned to the newly forked session.</returns>
    public async Task<SessionsForkResult> ForkAsync(string sessionId, string? toEventId = null, string? name = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsForkRequest { SessionId = sessionId, ToEventId = toEventId, Name = name };
        return await CopilotClient.InvokeRpcAsync<SessionsForkResult>(_rpc, "sessions.fork", [request], cancellationToken);
    }

    /// <summary>Connects to an existing remote session and exposes it as an SDK session.</summary>
    /// <param name="sessionId">Session ID to connect to.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Remote session connection result.</returns>
    public async Task<RemoteSessionConnectionResult> ConnectAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new ConnectRemoteSessionParams { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<RemoteSessionConnectionResult>(_rpc, "sessions.connect", [request], cancellationToken);
    }

    /// <summary>Lists sessions, optionally filtered by source and working-directory context. Returned entries are discriminated by `isRemote`: local entries carry only the lightweight `LocalSessionMetadataValue` shape; remote entries carry the full `RemoteSessionMetadataValue` shape (repository, PR number, taskType, etc.).</summary>
    /// <param name="source">Which session sources to include. Defaults to `local` for backward compatibility.</param>
    /// <param name="metadataLimit">When provided, only the first N local sessions (sorted by modification time, newest first) load full metadata; remaining sessions return basic info only. Use 0 to return only basic info for every local session. Has no effect on remote entries (which always carry their full shape).</param>
    /// <param name="filter">Optional filter applied to the returned sessions.</param>
    /// <param name="includeDetached">When true, include detached maintenance sessions. Defaults to false for user-facing session lists.</param>
    /// <param name="throwOnError">Only meaningful when `source` includes remote. When true, propagates errors from the remote service instead of silently returning an empty remote list. Defaults to false.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Sessions matching the filter, ordered most-recently-modified first.</returns>
    public async Task<SessionList> ListAsync(SessionSource? source = null, long? metadataLimit = null, SessionListFilter? filter = null, bool? includeDetached = null, bool? throwOnError = null, CancellationToken cancellationToken = default)
    {
        var request = new SessionsListRequest { Source = source, MetadataLimit = metadataLimit, Filter = filter, IncludeDetached = includeDetached, ThrowOnError = throwOnError };
        return await CopilotClient.InvokeRpcAsync<SessionList>(_rpc, "sessions.list", [request], cancellationToken);
    }

    /// <summary>Reads lightweight persisted metadata for one local session without opening it.</summary>
    /// <param name="sessionId">Session ID to inspect.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Persisted local session metadata when the session exists.</returns>
    internal async Task<SessionsGetMetadataResult> GetMetadataAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsGetMetadataRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionsGetMetadataResult>(_rpc, "sessions.getMetadata", [request], cancellationToken);
    }

    /// <summary>Reads client-owned metadata for multiple persisted local sessions without opening them. Results preserve request order and report missing, corrupt, unsupported, or temporarily unavailable sessions independently.</summary>
    /// <param name="sessionIds">Session IDs to inspect. Results preserve this order.</param>
    /// <param name="keys">Case-sensitive keys to project from each valid bag. Each key must be non-empty, at most 256 UTF-8 bytes, and outside the reserved `copilot/` and `github/` namespaces. Omit to return every entry.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Ordered client metadata outcomes for the requested local sessions.</returns>
    public async Task<IList<SessionsClientMetadataEntry>> GetClientMetadataAsync(IList<string> sessionIds, IList<string>? keys = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionIds);

        var request = new SessionsGetClientMetadataRequest { SessionIds = sessionIds, Keys = keys };
        return await CopilotClient.InvokeRpcAsync<IList<SessionsClientMetadataEntry>>(_rpc, "sessions.getClientMetadata", [request], cancellationToken);
    }

    /// <summary>Reads a page of durable events directly from a local session's persisted journal without creating, resuming, or activating the session. The initial backward read uses a bounded tail scan for fast first paint; cursor continuations preserve the session event-log paging semantics. Persisted events may omit payloads that are reconstructed only for an active session.</summary>
    /// <param name="sessionId">Session ID whose persisted event journal should be read.</param>
    /// <param name="cursor">Opaque cursor returned by a previous persisted-event read. Omit on the first call.</param>
    /// <param name="max">Maximum number of events to return in this batch (1–1000, default 200).</param>
    /// <param name="direction">Direction to page through persisted history. Forward starts at the beginning; backward starts with the newest events. Events in each page remain chronological.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Batch of session events returned by a read, with cursor and continuation metadata.</returns>
    public async Task<EventsReadResult> ReadPersistedEventsAsync(string sessionId, string? cursor = null, long? max = null, EventsReadDirection? direction = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsReadPersistedEventsRequest { SessionId = sessionId, Cursor = cursor, Max = max, Direction = direction };
        return await CopilotClient.InvokeRpcAsync<EventsReadResult>(_rpc, "sessions.readPersistedEvents", [request], cancellationToken);
    }

    /// <summary>Lists recent local session IDs that contain user-visible history, omitting housekeeping-only sessions.</summary>
    /// <param name="limit">Maximum number of session IDs to return.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Recent local session IDs that contain user-visible history.</returns>
    internal async Task<SessionsListNonEmptySessionIdsResult> ListNonEmptySessionIdsAsync(long? limit = null, CancellationToken cancellationToken = default)
    {
        var request = new SessionsListNonEmptySessionIdsRequest { Limit = limit };
        return await CopilotClient.InvokeRpcAsync<SessionsListNonEmptySessionIdsResult>(_rpc, "sessions.listNonEmptySessionIds", [request], cancellationToken);
    }

    /// <summary>Finds the local session bound to a GitHub task ID, if any.</summary>
    /// <param name="taskId">GitHub task ID to look up.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>ID of the local session bound to the given GitHub task, or omitted when none.</returns>
    public async Task<SessionsFindByTaskIDResult> FindByTaskIdAsync(string taskId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(taskId);

        var request = new SessionsFindByTaskIDRequest { TaskId = taskId };
        return await CopilotClient.InvokeRpcAsync<SessionsFindByTaskIDResult>(_rpc, "sessions.findByTaskId", [request], cancellationToken);
    }

    /// <summary>Resolves a UUID prefix to a unique session ID, if exactly one session matches.</summary>
    /// <param name="prefix">UUID prefix (&gt;=7 hex chars, &lt;36 chars). Returns the unique session ID, or undefined when there is no match or the prefix matches multiple sessions.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Session ID matching the prefix, omitted when no unique match exists.</returns>
    public async Task<SessionsFindByPrefixResult> FindByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(prefix);

        var request = new SessionsFindByPrefixRequest { Prefix = prefix };
        return await CopilotClient.InvokeRpcAsync<SessionsFindByPrefixResult>(_rpc, "sessions.findByPrefix", [request], cancellationToken);
    }

    /// <summary>Returns the most-relevant prior session for a given working-directory context.</summary>
    /// <param name="context">Optional working-directory context used to score session relevance. When omitted the most-recently-modified session wins.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Most-relevant session ID for the supplied context, or omitted when no sessions exist.</returns>
    public async Task<SessionsGetLastForContextResult> GetLastForContextAsync(SessionContext? context = null, CancellationToken cancellationToken = default)
    {
        var request = new SessionsGetLastForContextRequest { Context = context };
        return await CopilotClient.InvokeRpcAsync<SessionsGetLastForContextResult>(_rpc, "sessions.getLastForContext", [request], cancellationToken);
    }

    /// <summary>Computes the absolute path to a session's persisted events.jsonl file. Internal: filesystem paths are only meaningful in-process (CLI and runtime share a filesystem). Currently used by the CLI's contribution-graph feature to read historical events directly. Remote SDK consumers must not depend on this; a proper event-query API would replace it if the contribution graph ever needed to work over the wire.</summary>
    /// <param name="sessionId">Session ID whose event-log file path to compute.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Absolute path to the session's events.jsonl file on disk.</returns>
    internal async Task<SessionsGetEventFilePathResult> GetEventFilePathAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsGetEventFilePathRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionsGetEventFilePathResult>(_rpc, "sessions.getEventFilePath", [request], cancellationToken);
    }

    /// <summary>Returns the on-disk byte size of each session's workspace directory.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Map of sessionId -&gt; on-disk size in bytes for each session's workspace directory.</returns>
    public async Task<SessionSizes> GetSizesAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<SessionSizes>(_rpc, "sessions.getSizes", [], cancellationToken);
    }

    /// <summary>Returns the subset of the supplied session IDs that are currently held by another running process.</summary>
    /// <param name="sessionIds">Session IDs to test for live in-use locks.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Session IDs from the input set that are currently in use by another process.</returns>
    public async Task<SessionsCheckInUseResult> CheckInUseAsync(IList<string> sessionIds, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionIds);

        var request = new SessionsCheckInUseRequest { SessionIds = sessionIds };
        return await CopilotClient.InvokeRpcAsync<SessionsCheckInUseResult>(_rpc, "sessions.checkInUse", [request], cancellationToken);
    }

    /// <summary>Returns a session's persisted remote-steerable flag, if any has been recorded. Internal: this is CLI-specific book-keeping used by `--continue` / `--resume` to inherit the prior session's remote-steerable preference. SDK consumers that want similar behavior should manage their own persistence around start/stop calls rather than relying on this runtime-side flag.</summary>
    /// <param name="sessionId">Session ID to look up the persisted remote-steerable flag for.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The session's persisted remote-steerable flag, or omitted when no value has been persisted.</returns>
    internal async Task<SessionsGetPersistedRemoteSteerableResult> GetPersistedRemoteSteerableAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsGetPersistedRemoteSteerableRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionsGetPersistedRemoteSteerableResult>(_rpc, "sessions.getPersistedRemoteSteerable", [request], cancellationToken);
    }

    /// <summary>Closes a session: emits shutdown, flushes pending events, releases the in-use lock, and disposes the active session.</summary>
    /// <param name="sessionId">Session ID to close.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Closes a session: emits shutdown, flushes pending events to disk, releases the in-use lock, disposes the active session. Idempotent: succeeds even if the session is not currently active.</returns>
    public async Task<SessionsCloseResult> CloseAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsCloseRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionsCloseResult>(_rpc, "sessions.close", [request], cancellationToken);
    }

    /// <summary>Closes, deactivates, and deletes a set of sessions, returning the bytes freed per session.</summary>
    /// <param name="sessionIds">Session IDs to close, deactivate, and delete from disk.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Map of sessionId -&gt; bytes freed by removing the session's workspace directory.</returns>
    public async Task<SessionBulkDeleteResult> BulkDeleteAsync(IList<string> sessionIds, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionIds);

        var request = new SessionsBulkDeleteRequest { SessionIds = sessionIds };
        return await CopilotClient.InvokeRpcAsync<SessionBulkDeleteResult>(_rpc, "sessions.bulkDelete", [request], cancellationToken);
    }

    /// <summary>Deletes one local session from disk after running the same lifecycle hooks as the session manager.</summary>
    /// <param name="sessionId">Session ID to delete.</param>
    /// <param name="sessionPath">Internal resolved session directory path to delete.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task DeleteAsync(string sessionId, string? sessionPath = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsDeleteRequest { SessionId = sessionId, SessionPath = sessionPath };
        await CopilotClient.InvokeRpcAsync(_rpc, "sessions.delete", [request], cancellationToken);
    }

    /// <summary>Deletes sessions older than the given threshold, with optional dry-run and exclusion list.</summary>
    /// <param name="olderThanDays">Delete sessions whose modifiedTime is at least this many days old.</param>
    /// <param name="dryRun">When true, only report what would be deleted without performing any deletion.</param>
    /// <param name="includeNamed">When true, named sessions (set via /rename) are also eligible for pruning.</param>
    /// <param name="excludeSessionIds">Session IDs that should never be considered for pruning.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of the prune operation: deleted IDs, dry-run candidates, skipped IDs, total bytes freed, and the dry-run flag.</returns>
    public async Task<SessionPruneResult> PruneOldAsync(long olderThanDays, bool? dryRun = null, bool? includeNamed = null, IList<string>? excludeSessionIds = null, CancellationToken cancellationToken = default)
    {
        var request = new SessionsPruneOldRequest { OlderThanDays = olderThanDays, DryRun = dryRun, IncludeNamed = includeNamed, ExcludeSessionIds = excludeSessionIds };
        return await CopilotClient.InvokeRpcAsync<SessionPruneResult>(_rpc, "sessions.pruneOld", [request], cancellationToken);
    }

    /// <summary>Flushes a session's pending events to disk.</summary>
    /// <param name="sessionId">Session ID whose pending events should be flushed to disk.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Flush a session's pending events to disk. No-op when no writer exists for the session (e.g., already closed).</returns>
    public async Task<SessionsSaveResult> SaveAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsSaveRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionsSaveResult>(_rpc, "sessions.save", [request], cancellationToken);
    }

    /// <summary>Releases the in-use lock held by this process for a session.</summary>
    /// <param name="sessionId">Session ID whose in-use lock should be released.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Release the in-use lock held by this process for the given session. No-op when this process does not currently hold a lock for the session.</returns>
    public async Task<SessionsReleaseLockResult> ReleaseLockAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsReleaseLockRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionsReleaseLockResult>(_rpc, "sessions.releaseLock", [request], cancellationToken);
    }

    /// <summary>Backfills missing summary and context fields on the supplied session metadata records.</summary>
    /// <param name="sessions">Session metadata records to enrich. Records that already have summary and context are returned unchanged.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The enriched metadata records, with summary and context fields backfilled where available. Sessions confirmed empty and unnamed are omitted.</returns>
    public async Task<SessionEnrichMetadataResult> EnrichMetadataAsync(IList<LocalSessionMetadataValue> sessions, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessions);

        var request = new SessionsEnrichMetadataRequest { Sessions = sessions };
        return await CopilotClient.InvokeRpcAsync<SessionEnrichMetadataResult>(_rpc, "sessions.enrichMetadata", [request], cancellationToken);
    }

    /// <summary>Reloads user, plugin, and (optionally) repo hooks on the active session.</summary>
    /// <param name="sessionId">Active session ID to reload hooks for.</param>
    /// <param name="deferRepoHooks">When true, skip repo-level hooks. Use before folder trust is confirmed; loadDeferredRepoHooks loads them post-trust.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Reload all hooks (user, plugin, optionally repo) and apply them to the active session. Call after installing or removing plugins so their hooks take effect immediately. No-op when no active session matches the given sessionId.</returns>
    public async Task<SessionsReloadPluginHooksResult> ReloadPluginHooksAsync(string sessionId, bool? deferRepoHooks = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsReloadPluginHooksRequest { SessionId = sessionId, DeferRepoHooks = deferRepoHooks };
        return await CopilotClient.InvokeRpcAsync<SessionsReloadPluginHooksResult>(_rpc, "sessions.reloadPluginHooks", [request], cancellationToken);
    }

    /// <summary>Loads previously-deferred repo-level hooks on the active session, returning queued startup prompts.</summary>
    /// <param name="sessionId">Active session ID whose deferred repo-level hooks should be loaded.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Queued repo-level startup prompts and the total hook command count after loading.</returns>
    public async Task<SessionLoadDeferredRepoHooksResult> LoadDeferredRepoHooksAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsLoadDeferredRepoHooksRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionLoadDeferredRepoHooksResult>(_rpc, "sessions.loadDeferredRepoHooks", [request], cancellationToken);
    }

    /// <summary>Replaces the manager-wide additional plugins registered with the session manager.</summary>
    /// <param name="plugins">Manager-wide additional plugins to register. Replaces any previously-configured set. Pass an empty array to clear.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Replace the manager-wide additional plugins. New session creations and subsequent hook reloads see the new set; already-running sessions keep their existing hook installation until the next reload.</returns>
    public async Task<SessionsSetAdditionalPluginsResult> SetAdditionalPluginsAsync(IList<InstalledPlugin> plugins, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(plugins);

        var request = new SessionsSetAdditionalPluginsRequest { Plugins = plugins };
        return await CopilotClient.InvokeRpcAsync<SessionsSetAdditionalPluginsResult>(_rpc, "sessions.setAdditionalPlugins", [request], cancellationToken);
    }

    /// <summary>Gets the dynamic-context board entry count associated with a session, when available. Internal: this exists solely so CLI telemetry events (`rem_spawn_gate`, `rem_consolidation_complete`) can pair START / END board counts around the detached rem-agent spawn. "Dynamic context board" is a runtime-internal concept that is not part of the public SDK contract; the long-term plan is to relocate the telemetry emission into the runtime so this method can be deleted entirely.</summary>
    /// <param name="sessionId">Session ID whose board entry count should be returned.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Dynamic-context board entry count, when available.</returns>
    internal async Task<SessionsGetBoardEntryCountResult> GetBoardEntryCountAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new SessionsGetBoardEntryCountRequest { SessionId = sessionId };
        return await CopilotClient.InvokeRpcAsync<SessionsGetBoardEntryCountResult>(_rpc, "sessions.getBoardEntryCount", [request], cancellationToken);
    }

    /// <summary>Attaches the runtime-managed remote-control singleton to a session, awaiting initial setup. If remote control is already attached to a different session, the singleton is transferred (preserving the underlying Mission Control connection). Returns the final status.</summary>
    /// <param name="sessionId">Local session id to attach remote control to.</param>
    /// <param name="config">Configuration for the runtime-managed remote-control singleton.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Wrapper for the singleton's current status.</returns>
    public async Task<RemoteControlStatusResult> StartRemoteControlAsync(string sessionId, RemoteControlConfig config, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);
        ArgumentNullException.ThrowIfNull(config);

        var request = new SessionsStartRemoteControlRequest { SessionId = sessionId, Config = config };
        return await CopilotClient.InvokeRpcAsync<RemoteControlStatusResult>(_rpc, "sessions.startRemoteControl", [request], cancellationToken);
    }

    /// <summary>Atomically rebinds the remote-control singleton to a different session, preserving the underlying Mission Control connection. When `expectedFromSessionId` is provided and does not match the singleton's current `attachedSessionId`, the transfer is rejected with `transferred: false` and the current status is returned unchanged.</summary>
    /// <param name="toSessionId">Local session id to point remote control at.</param>
    /// <param name="expectedFromSessionId">When provided, the transfer is rejected unless the singleton currently points at this session id (compare-and-swap semantics to avoid clobbering newer state).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of a transferRemoteControl call.</returns>
    public async Task<RemoteControlTransferResult> TransferRemoteControlAsync(string toSessionId, string? expectedFromSessionId = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(toSessionId);

        var request = new SessionsTransferRemoteControlRequest { ToSessionId = toSessionId, ExpectedFromSessionId = expectedFromSessionId };
        return await CopilotClient.InvokeRpcAsync<RemoteControlTransferResult>(_rpc, "sessions.transferRemoteControl", [request], cancellationToken);
    }

    /// <summary>Patches the steering state of the active remote-control singleton. When remote control is off, this is a no-op and the off status is returned. Today only `enabled: true` is actionable on the underlying exporter; passing `false` is reserved for future use.</summary>
    /// <param name="enabled">Target steering state. Today only `true` is actionable on the underlying exporter; `false` is reserved for future use.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Wrapper for the singleton's current status.</returns>
    public async Task<RemoteControlStatusResult> SetRemoteControlSteeringAsync(bool enabled, CancellationToken cancellationToken = default)
    {
        var request = new SessionsSetRemoteControlSteeringRequest { Enabled = enabled };
        return await CopilotClient.InvokeRpcAsync<RemoteControlStatusResult>(_rpc, "sessions.setRemoteControlSteering", [request], cancellationToken);
    }

    /// <summary>Stops the remote-control singleton. When `expectedSessionId` is provided and does not match the singleton's current `attachedSessionId`, the stop is rejected with `stopped: false` and the current status is returned unchanged (unless `force` is set, in which case the singleton is unconditionally torn down).</summary>
    /// <param name="expectedSessionId">When provided, the stop is rejected unless the singleton currently points at this session id (compare-and-swap semantics).</param>
    /// <param name="force">When true, the singleton is unconditionally torn down regardless of `expectedSessionId`. Use during shutdown or explicit `/remote off`.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of a stopRemoteControl call.</returns>
    public async Task<RemoteControlStopResult> StopRemoteControlAsync(string? expectedSessionId = null, bool? force = null, CancellationToken cancellationToken = default)
    {
        var request = new SessionsStopRemoteControlRequest { ExpectedSessionId = expectedSessionId, Force = force };
        return await CopilotClient.InvokeRpcAsync<RemoteControlStopResult>(_rpc, "sessions.stopRemoteControl", [request], cancellationToken);
    }

    /// <summary>Returns the current state of the remote-control singleton, including the attached session id and frontend URL when active.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Wrapper for the singleton's current status.</returns>
    public async Task<RemoteControlStatusResult> GetRemoteControlStatusAsync(CancellationToken cancellationToken = default)
    {
        return await CopilotClient.InvokeRpcAsync<RemoteControlStatusResult>(_rpc, "sessions.getRemoteControlStatus", [], cancellationToken);
    }

    /// <summary>Registers extension-provided tools on the given session, gated by an optional `enabled` callback. Returns an opaque unsubscribe function the caller must invoke to deregister the tools when the extension is torn down. Marked internal because `loader`, `enabled`, and the returned `unsubscribe` are in-process handles that cannot cross the JSON-RPC boundary. Disappears once extension discovery / launch / tool registration are owned by the runtime: SDK consumers will pass pure config (search paths, disabled ids) via `SessionOptions` and the runtime will resolve, launch, register, and tear down extensions itself.</summary>
    /// <param name="sessionId">Session to register extension tools on.</param>
    /// <param name="options">Optional registration options.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Handle for releasing the extension tool registration.</returns>
    internal async Task<RegisterExtensionToolsResult> RegisterExtensionToolsOnSessionAsync(string sessionId, SessionsRegisterExtensionToolsOnSessionOptions? options = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new RegisterExtensionToolsParams { SessionId = sessionId, Options = options };
        return await CopilotClient.InvokeRpcAsync<RegisterExtensionToolsResult>(_rpc, "sessions.registerExtensionToolsOnSession", [request], cancellationToken);
    }

    /// <summary>Attaches (or detaches) an in-process ExtensionController delegate for the given session, used by shared-API surfaces that need to query or modify the session's extension state. Pass `controller: undefined` to detach. Marked internal because the controller is an in-process object that cannot cross the JSON-RPC boundary. Disappears alongside `registerExtensionToolsOnSession`: once the runtime owns extension management, the public surface exposes list/enable/disable/reload as dedicated RPCs served by the runtime.</summary>
    /// <param name="sessionId">Session to attach the extension controller delegate to.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task ConfigureSessionExtensionsAsync(string sessionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(sessionId);

        var request = new ConfigureSessionExtensionsParams { SessionId = sessionId };
        await CopilotClient.InvokeRpcAsync(_rpc, "sessions.configureSessionExtensions", [request], cancellationToken);
    }
}

/// <summary>Provides server-scoped AgentRegistry APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ServerAgentRegistryApi
{
    private readonly JsonRpc _rpc;

    internal ServerAgentRegistryApi(JsonRpc rpc)
    {
        _rpc = rpc;
    }

    /// <summary>Spawns a managed-server child with the supplied configuration and returns a discriminated-union result. The caller (typically the CLI controller) is responsible for attaching to the spawned child and sending any follow-up prompt. When the controller-local spawn gate is closed the server returns JSON-RPC MethodNotFound.</summary>
    /// <param name="cwd">Working directory for the spawned child (must be an existing directory).</param>
    /// <param name="agentName">Custom or built-in agent name (e.g. 'explore'). When omitted, the child uses its own default.</param>
    /// <param name="model">Model identifier to apply to the new session.</param>
    /// <param name="name">Friendly session name. Must satisfy validateSessionName: non-empty, no leading/trailing whitespace, &lt;=100 chars, no control chars, no double quotes.</param>
    /// <param name="permissionMode">Permission posture for the new session. 'yolo' requires the controller-local session to currently be in allow-all mode.</param>
    /// <param name="initialPrompt">Optional first user message. Forwarded to the caller (the CLI's spawn wrapper sends it post-attach via the standard LocalRpcSession.send path).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of an agentRegistry.spawn call.</returns>
    public async Task<AgentRegistrySpawnResult> SpawnAsync(string cwd, string? agentName = null, string? model = null, string? name = null, AgentRegistrySpawnPermissionMode? permissionMode = null, string? initialPrompt = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(cwd);

        var request = new AgentRegistrySpawnRequest { Cwd = cwd, AgentName = agentName, Model = model, Name = name, PermissionMode = permissionMode, InitialPrompt = initialPrompt };
        return await CopilotClient.InvokeRpcAsync<AgentRegistrySpawnResult>(_rpc, "agentRegistry.spawn", [request], cancellationToken);
    }
}

/// <summary>Provides typed session-scoped RPC methods.</summary>
public sealed class SessionRpc
{
    private readonly CopilotSession _session;

    internal SessionRpc(CopilotSession session)
    {
        _session = session;
    }

    internal CopilotSession Session => _session;

    /// <summary>Sandbox APIs.</summary>
    public SandboxApi Sandbox =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>GitHubAuth APIs.</summary>
    public GitHubAuthApi GitHubAuth =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Debug APIs.</summary>
    public DebugApi Debug =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Canvas APIs.</summary>
    public CanvasApi Canvas =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Factory APIs.</summary>
    public FactoryApi Factory =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Model APIs.</summary>
    public ModelApi Model =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Mode APIs.</summary>
    public ModeApi Mode =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Name APIs.</summary>
    public NameApi Name =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Plan APIs.</summary>
    public PlanApi Plan =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Workspaces APIs.</summary>
    public WorkspacesApi Workspaces =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>AutopilotObjective APIs.</summary>
    public AutopilotObjectiveApi AutopilotObjective =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Completions APIs.</summary>
    public CompletionsApi Completions =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Instructions APIs.</summary>
    public InstructionsApi Instructions =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Fleet APIs.</summary>
    public FleetApi Fleet =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Agent APIs.</summary>
    public AgentApi Agent =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Tasks APIs.</summary>
    public TasksApi Tasks =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Skills APIs.</summary>
    public SkillsApi Skills =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Mcp APIs.</summary>
    public McpApi Mcp =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Plugins APIs.</summary>
    public PluginsApi Plugins =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Provider APIs.</summary>
    public ProviderApi Provider =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Options APIs.</summary>
    public OptionsApi Options =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Lsp APIs.</summary>
    public LspApi Lsp =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Extensions APIs.</summary>
    public ExtensionsApi Extensions =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Tools APIs.</summary>
    public ToolsApi Tools =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Commands APIs.</summary>
    public CommandsApi Commands =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Telemetry APIs.</summary>
    public TelemetryApi Telemetry =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Ui APIs.</summary>
    public UiApi Ui =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Permissions APIs.</summary>
    public PermissionsApi Permissions =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Metadata APIs.</summary>
    public MetadataApi Metadata =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Settings APIs.</summary>
    public SettingsApi Settings =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>ContentExclusion APIs.</summary>
    public ContentExclusionApi ContentExclusion =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Shell APIs.</summary>
    public ShellApi Shell =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>History APIs.</summary>
    public HistoryApi History =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Queue APIs.</summary>
    public QueueApi Queue =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>EventLog APIs.</summary>
    public EventLogApi EventLog =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Usage APIs.</summary>
    public UsageApi Usage =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>LimitPrediction APIs.</summary>
    public LimitPredictionApi LimitPrediction =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Remote APIs.</summary>
    public RemoteApi Remote =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Visibility APIs.</summary>
    public VisibilityApi Visibility =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Schedule APIs.</summary>
    public ScheduleApi Schedule =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Suspends the session while preserving persisted state for later resume.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    [Experimental(Diagnostics.Experimental)]
    public async Task SuspendAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSuspendRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.suspend", [request], cancellationToken);
    }

    /// <summary>Sends a user message to the session and returns its message ID.</summary>
    /// <param name="prompt">The user message text.</param>
    /// <param name="displayPrompt">If provided, this is shown in the timeline instead of `prompt`.</param>
    /// <param name="attachments">Optional attachments (files, directories, selections, blobs, GitHub references) to include with the message.</param>
    /// <param name="mode">How to deliver the message. `enqueue` (default) appends to the message queue. `immediate` interjects during an in-progress turn.</param>
    /// <param name="prepend">If true, adds the message to the front of the queue instead of the end.</param>
    /// <param name="billable">If false, this message will not trigger a Premium Request Unit charge. User messages default to billable.</param>
    /// <param name="requiredTool">If set, the request will fail if the named tool is not available when this message is among the user messages at the start of the current exchange.</param>
    /// <param name="source">Optional provenance tag copied to the resulting user.message event. Must be `user`, `system`, `command-&lt;command-id&gt;` for command-originated messages, `schedule-&lt;numeric-id&gt;` for scheduled prompts, or `agent-&lt;agent-id&gt;` for prompts sent by another agent.</param>
    /// <param name="agentMode">The UI mode the agent was in when this message was sent. Defaults to the session's current mode.</param>
    /// <param name="requestHeaders">Custom HTTP headers to include in outbound model requests for this turn. Merged with session-level provider headers; per-turn headers augment and overwrite session-level headers with the same key.</param>
    /// <param name="traceparent">W3C Trace Context traceparent header for distributed tracing of this agent turn.</param>
    /// <param name="tracestate">W3C Trace Context tracestate header for distributed tracing.</param>
    /// <param name="wait">If true, await completion of the agentic loop for this message before returning. Defaults to false (fire-and-forget). When true, the result still contains the same `messageId`; the caller can rely on the agent having processed the message before the call resolves. Transport-dependent tail semantics: on a LOCAL (in-process) session the wait additionally blocks until the completed turn's event tail has been dispatched to this session's in-process subscribers, so a subsequent read of subscriber state already reflects the turn; on a REMOTE session the wait resolves once the loop completes and mirrored delivery follows over the wire. Callers that need the stronger local guarantee on remote sessions should await the event stream explicitly.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of sending a user message.</returns>
    [Experimental(Diagnostics.Experimental)]
    public async Task<SendResult> SendAsync(string prompt, string? displayPrompt = null, IList<Attachment>? attachments = null, SendMode? mode = null, bool? prepend = null, bool? billable = null, string? requiredTool = null, string? source = null, SendAgentMode? agentMode = null, IDictionary<string, string>? requestHeaders = null, string? traceparent = null, string? tracestate = null, bool? wait = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new SendRequest { SessionId = _session.SessionId, Prompt = prompt, DisplayPrompt = displayPrompt, Attachments = attachments, Mode = mode, Prepend = prepend, Billable = billable, RequiredTool = requiredTool, Source = source, AgentMode = agentMode, RequestHeaders = requestHeaders, Traceparent = traceparent, Tracestate = tracestate, Wait = wait };
        return await CopilotClient.InvokeRpcAsync<SendResult>(_session.Rpc, "session.send", [request], cancellationToken);
    }

    /// <summary>Sends zero or more user messages to the session in a single turn and returns their message IDs. All provided messages are appended to the conversation in order, then exactly one agent turn runs over the resulting history. When the list is empty, one turn runs over the existing history with no new user message. Remote-backed (Mission Control) sessions do not support this method and will return an error.</summary>
    /// <param name="messages">The user messages to append to the conversation, in order. May be empty, in which case a single turn runs over the existing history with no new user message.</param>
    /// <param name="mode">How to deliver the messages. `enqueue` (default) appends to the message queue. `immediate` interjects during an in-progress turn.</param>
    /// <param name="prepend">If true, adds the messages to the front of the queue instead of the end.</param>
    /// <param name="agentMode">The UI mode the agent was in when these messages were sent. Defaults to the session's current mode.</param>
    /// <param name="requestHeaders">Custom HTTP headers to include in outbound model requests for this turn. Merged with session-level provider headers; per-turn headers augment and overwrite session-level headers with the same key.</param>
    /// <param name="traceparent">W3C Trace Context traceparent header for distributed tracing of this agent turn.</param>
    /// <param name="tracestate">W3C Trace Context tracestate header for distributed tracing.</param>
    /// <param name="wait">If true, await completion of the agentic loop for this turn before returning. Defaults to false (fire-and-forget). When true, the result still contains the same `messageIds`; the caller can rely on the agent having processed the messages before the call resolves. Transport-dependent tail semantics: on a LOCAL (in-process) session the wait additionally blocks until the completed turn's event tail has been dispatched to this session's in-process subscribers, so a subsequent read of subscriber state already reflects the turn; on a REMOTE session the wait resolves once the loop completes and mirrored delivery follows over the wire. Callers that need the stronger local guarantee on remote sessions should await the event stream explicitly.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of sending zero or more user messages.</returns>
    [Experimental(Diagnostics.Experimental)]
    public async Task<SendMessagesResult> SendMessagesAsync(IList<SendMessageItem> messages, SendMode? mode = null, bool? prepend = null, SendAgentMode? agentMode = null, IDictionary<string, string>? requestHeaders = null, string? traceparent = null, string? tracestate = null, bool? wait = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(messages);
        _session.ThrowIfDisposed();

        var request = new SendMessagesRequest { SessionId = _session.SessionId, Messages = messages, Mode = mode, Prepend = prepend, AgentMode = agentMode, RequestHeaders = requestHeaders, Traceparent = traceparent, Tracestate = tracestate, Wait = wait };
        return await CopilotClient.InvokeRpcAsync<SendMessagesResult>(_session.Rpc, "session.sendMessages", [request], cancellationToken);
    }

    /// <summary>Queues or sends an internal system notification to the session according to its passive policy.</summary>
    /// <param name="message">Notification text to deliver to the model.</param>
    /// <param name="kind">Optional structured notification kind.</param>
    /// <param name="options">Internal delivery options, including passive policy.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    [Experimental(Diagnostics.Experimental)]
    internal async Task SendSystemNotificationAsync(string message, object? kind = null, object? options = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(message);
        _session.ThrowIfDisposed();

        var request = new SendSystemNotificationRequest { SessionId = _session.SessionId, Message = message, Kind = CopilotClient.ToJsonElementForWire(kind), Options = CopilotClient.ToJsonElementForWire(options) };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.sendSystemNotification", [request], cancellationToken);
    }

    /// <summary>Aborts the current agent turn.</summary>
    /// <param name="reason">Finite reason code describing why the current turn was aborted.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of aborting the current turn.</returns>
    [Experimental(Diagnostics.Experimental)]
    public async Task<AbortResult> AbortAsync(AbortReason? reason = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new AbortRequest { SessionId = _session.SessionId, Reason = reason };
        return await CopilotClient.InvokeRpcAsync<AbortResult>(_session.Rpc, "session.abort", [request], cancellationToken);
    }

    /// <summary>Interrupts the current main agent turn while leaving running background work (subagents, sidekicks, and promoted attached shells) alive. No-op when the main loop is not processing.</summary>
    /// <param name="flushQueued">When true, the user's queued prompts are preserved and run as the next turn once the interrupted turn unwinds; when false (the default), the queue is cleared like a plain abort.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of interrupting the main agent turn.</returns>
    [Experimental(Diagnostics.Experimental)]
    public async Task<InterruptMainTurnResult> InterruptMainTurnAsync(bool? flushQueued = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new InterruptMainTurnRequest { SessionId = _session.SessionId, FlushQueued = flushQueued };
        return await CopilotClient.InvokeRpcAsync<InterruptMainTurnResult>(_session.Rpc, "session.interruptMainTurn", [request], cancellationToken);
    }

    /// <summary>Cancels every running background agent (task-registry subagents plus sidekick agents) without interrupting the main agent loop. Promoted attached shells are left running.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The number of running background agents (task-registry agents) that were cancelled.</returns>
    [Experimental(Diagnostics.Experimental)]
    public async Task<long> CancelAllBackgroundAgentsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionCancelAllBackgroundAgentsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<long>(_session.Rpc, "session.cancelAllBackgroundAgents", [request], cancellationToken);
    }

    /// <summary>Shuts down the session and persists its final state. Awaits any deferred sessionEnd hooks before resolving so user-supplied hook scripts complete before the runtime tears down.</summary>
    /// <param name="type">Why the session is being shut down. Defaults to "routine" when omitted.</param>
    /// <param name="reason">Optional human-readable reason. Typically the message of the error that triggered shutdown when type is 'error'.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    [Experimental(Diagnostics.Experimental)]
    public async Task ShutdownAsync(ShutdownType? type = null, string? reason = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ShutdownRequest { SessionId = _session.SessionId, Type = type, Reason = reason };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.shutdown", [request], cancellationToken);
    }

    /// <summary>Emits a user-visible session log event.</summary>
    /// <param name="message">Human-readable message.</param>
    /// <param name="level">Log severity level. Determines how the message is displayed in the timeline. Defaults to "info".</param>
    /// <param name="type">Domain category for this log entry (e.g., "mcp", "subscription", "policy", "model"). Maps to `infoType`/`warningType`/`errorType` on the emitted event. Defaults to "notification".</param>
    /// <param name="ephemeral">When true, the message is transient and not persisted to the session event log on disk.</param>
    /// <param name="url">Optional URL the user can open in their browser for more details.</param>
    /// <param name="tip">Optional actionable tip displayed alongside the message. Only honored on `level: "info"`.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Identifier of the session event that was emitted for the log message.</returns>
    [Experimental(Diagnostics.Experimental)]
    public async Task<LogResult> LogAsync(string message, SessionLogLevel? level = null, string? type = null, bool? ephemeral = null, string? url = null, string? tip = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(message);
        _session.ThrowIfDisposed();

        var request = new LogRequest { SessionId = _session.SessionId, Message = message, Level = level, Type = type, Ephemeral = ephemeral, Url = url, Tip = tip };
        return await CopilotClient.InvokeRpcAsync<LogResult>(_session.Rpc, "session.log", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Sandbox APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SandboxApi
{
    private readonly CopilotSession _session;

    internal SandboxApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Returns whether managed policy requires sandbox enforcement and whether an enforcement failure has permanently blocked the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Managed sandbox enforcement state for a session.</returns>
    public async Task<SandboxEnforcementStatus> GetEnforcementStatusAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSandboxGetEnforcementStatusRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SandboxEnforcementStatus>(_session.Rpc, "session.sandbox.getEnforcementStatus", [request], cancellationToken);
    }

    /// <summary>Disables sandboxing for the remainder of the current session and approves the referenced pending sandbox-bypass permission request. The request is rejected unless the exact request is still pending and the effective sandbox policy permits bypass.</summary>
    /// <param name="requestId">Identifier of the exact pending sandbox-bypass permission request that authorized the session opt-out.</param>
    /// <param name="decisionContext">Optional attribution for the permission decision.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of attempting to disable sandboxing for the current session.</returns>
    public async Task<SandboxDisableForSessionResult> DisableForSessionAsync(string requestId, PermissionDecisionContext? decisionContext = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new SandboxDisableForSessionRequest { SessionId = _session.SessionId, RequestId = requestId, DecisionContext = decisionContext };
        return await CopilotClient.InvokeRpcAsync<SandboxDisableForSessionResult>(_session.Rpc, "session.sandbox.disableForSession", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped GitHubAuth APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class GitHubAuthApi
{
    private readonly CopilotSession _session;

    internal GitHubAuthApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets authentication status and account metadata for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Authentication status and account metadata for the session.</returns>
    public async Task<SessionAuthStatus> GetStatusAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionGitHubAuthGetStatusRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SessionAuthStatus>(_session.Rpc, "session.gitHubAuth.getStatus", [request], cancellationToken);
    }

    /// <summary>Updates the session's auth credentials used for outbound model and API requests.</summary>
    /// <param name="credentials">The new auth credentials to install on the session. When omitted or `undefined`, the call is a no-op and the session's existing credentials are preserved. The runtime installs the supplied value immediately for outbound model/API requests. When the credential carries a raw token (`token`, `env`, or `gh-cli`) but no `copilotUser`, the runtime additionally re-resolves `copilotUser` server-side (best-effort, asynchronously, after the synchronous install) so plan/quota/billing metadata regains fidelity; on resolution failure the verbatim credential remains installed. It does NOT otherwise validate the credential. Several variants carry secret material; treat this method's params as containing secrets at rest and in transit.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the credential update succeeded.</returns>
    public async Task<SessionSetCredentialsResult> SetCredentialsAsync(SettableAuthInfo? credentials = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSetCredentialsParams { SessionId = _session.SessionId, Credentials = credentials };
        return await CopilotClient.InvokeRpcAsync<SessionSetCredentialsResult>(_session.Rpc, "session.gitHubAuth.setCredentials", [request], cancellationToken);
    }

    /// <summary>Gets the current authentication information for internal session hosts.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current authentication information, or null when no authentication is active.</returns>
    internal async Task<AuthIdentity?> GetCurrentAuthInfoAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionGitHubAuthGetCurrentAuthInfoRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<AuthIdentity?>(_session.Rpc, "session.gitHubAuth.getCurrentAuthInfo", [request], cancellationToken);
    }

    /// <summary>Gets all authentication accounts available to the internal session host.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Authentication accounts available to the internal session host.</returns>
    internal async Task<IList<SessionAuthStatus>> GetAllAuthAvailableAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionGitHubAuthGetAllAuthAvailableRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<IList<SessionAuthStatus>>(_session.Rpc, "session.gitHubAuth.getAllAuthAvailable", [request], cancellationToken);
    }

    /// <summary>Refreshes Copilot account metadata for the current authentication.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current authentication information, or null when no authentication is active.</returns>
    internal async Task<AuthIdentity?> RefreshCopilotUserAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionGitHubAuthRefreshCopilotUserRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<AuthIdentity?>(_session.Rpc, "session.gitHubAuth.refreshCopilotUser", [request], cancellationToken);
    }

    /// <summary>Logs in a GitHub user through the internal session host.</summary>
    /// <param name="host">GitHub host URL.</param>
    /// <param name="login">GitHub login.</param>
    /// <param name="token">GitHub authentication token.</param>
    /// <param name="persist">Whether to persist the token after login.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Authentication credentials accepted only at native protocol ingress. Runtime outputs use credential-free `AuthIdentity` metadata.</returns>
    internal async Task<AuthInfo> LoginAsync(string host, string login, string token, bool? persist = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(host);
        ArgumentNullException.ThrowIfNull(login);
        ArgumentNullException.ThrowIfNull(token);
        _session.ThrowIfDisposed();

        var request = new SessionAuthLoginRequest { SessionId = _session.SessionId, Host = host, Login = login, Token = token, Persist = persist };
        return await CopilotClient.InvokeRpcAsync<AuthInfo>(_session.Rpc, "session.gitHubAuth.login", [request], cancellationToken);
    }

    /// <summary>Switches the session to another available authentication.</summary>
    /// <param name="authInfo">Authentication information to activate.</param>
    /// <param name="token">Optional token paired with the authentication information.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task SwitchToAuthAsync(AuthInfo authInfo, string? token = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(authInfo);
        _session.ThrowIfDisposed();

        var request = new SessionAuthSwitchRequest { SessionId = _session.SessionId, AuthInfo = authInfo, Token = token };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.gitHubAuth.switchToAuth", [request], cancellationToken);
    }

    /// <summary>Logs out the session's current GitHub authentication.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the current authentication was logged out.</returns>
    internal async Task<bool> LogoutAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionGitHubAuthLogoutRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<bool>(_session.Rpc, "session.gitHubAuth.logout", [request], cancellationToken);
    }

    /// <summary>Logs out a specific GitHub authentication.</summary>
    /// <param name="authInfo">Authentication information to log out.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the requested authentication was logged out.</returns>
    internal async Task<bool> LogoutUserAsync(AuthInfo authInfo, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(authInfo);
        _session.ThrowIfDisposed();

        var request = new SessionAuthLogoutUserRequest { SessionId = _session.SessionId, AuthInfo = authInfo };
        return await CopilotClient.InvokeRpcAsync<bool>(_session.Rpc, "session.gitHubAuth.logoutUser", [request], cancellationToken);
    }

    /// <summary>Gets validation errors from the most recent authentication attempt.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Validation errors from the most recent authentication attempt.</returns>
    internal async Task<IList<AuthValidationError>> LastAuthErrorsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionGitHubAuthLastAuthErrorsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<IList<AuthValidationError>>(_session.Rpc, "session.gitHubAuth.lastAuthErrors", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Debug APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class DebugApi
{
    private readonly CopilotSession _session;

    internal DebugApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Collects a redacted session debug log bundle into a local archive or staging directory. The runtime includes session-owned logs by default and accepts caller-provided diagnostic entries so host applications can add their own files without changing this API shape.</summary>
    /// <param name="destination">Where the redacted bundle should be written. Use `archive` to produce a .tgz, or `directory` to stage redacted files for caller-managed upload/post-processing.</param>
    /// <param name="include">Which built-in session diagnostics to include. Omitted fields default to true.</param>
    /// <param name="additionalEntries">Caller-provided server-local files or directories to include in addition to the runtime's built-in session diagnostics. This lets host applications add their own diagnostics without changing the API shape.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of collecting a redacted debug bundle.</returns>
    public async Task<DebugCollectLogsResult> CollectLogsAsync(DebugCollectLogsDestination destination, DebugCollectLogsInclude? include = null, IList<DebugCollectLogsEntry>? additionalEntries = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(destination);
        _session.ThrowIfDisposed();

        var request = new DebugCollectLogsRequest { SessionId = _session.SessionId, Destination = destination, Include = include, AdditionalEntries = additionalEntries };
        return await CopilotClient.InvokeRpcAsync<DebugCollectLogsResult>(_session.Rpc, "session.debug.collectLogs", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Canvas APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasApi
{
    private readonly CopilotSession _session;

    internal CanvasApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists canvases declared for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Declared canvases available in this session.</returns>
    public async Task<CanvasList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionCanvasListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<CanvasList>(_session.Rpc, "session.canvas.list", [request], cancellationToken);
    }

    /// <summary>Lists currently open canvas instances for the live session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Live open-canvas snapshot.</returns>
    public async Task<CanvasListOpenResult> ListOpenAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionCanvasListOpenRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<CanvasListOpenResult>(_session.Rpc, "session.canvas.listOpen", [request], cancellationToken);
    }

    /// <summary>Opens or focuses a canvas instance.</summary>
    /// <param name="canvasId">Provider-local canvas identifier.</param>
    /// <param name="instanceId">Caller-supplied stable instance identifier.</param>
    /// <param name="extensionId">Owning provider identifier. Optional when the canvasId is unique across providers; required to disambiguate when multiple providers register the same canvasId.</param>
    /// <param name="input">Canvas open input.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Open canvas instance snapshot.</returns>
    public async Task<OpenCanvasInstance> OpenAsync(string canvasId, string instanceId, string? extensionId = null, object? input = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(canvasId);
        ArgumentNullException.ThrowIfNull(instanceId);
        _session.ThrowIfDisposed();

        var request = new CanvasOpenRequest { SessionId = _session.SessionId, CanvasId = canvasId, InstanceId = instanceId, ExtensionId = extensionId, Input = CopilotClient.ToJsonElementForWire(input) };
        return await CopilotClient.InvokeRpcAsync<OpenCanvasInstance>(_session.Rpc, "session.canvas.open", [request], cancellationToken);
    }

    /// <summary>Closes an open canvas instance.</summary>
    /// <param name="instanceId">Open canvas instance identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task CloseAsync(string instanceId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(instanceId);
        _session.ThrowIfDisposed();

        var request = new CanvasCloseRequest { SessionId = _session.SessionId, InstanceId = instanceId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.canvas.close", [request], cancellationToken);
    }

    /// <summary>Action APIs.</summary>
    public CanvasActionApi Action =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Provider APIs.</summary>
    public CanvasProviderApi Provider =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;
}

/// <summary>Provides session-scoped CanvasAction APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasActionApi
{
    private readonly CopilotSession _session;

    internal CanvasActionApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Invokes an action on an open canvas instance.</summary>
    /// <param name="instanceId">Open canvas instance identifier.</param>
    /// <param name="actionName">Action name to invoke.</param>
    /// <param name="input">Action input.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Canvas action invocation result.</returns>
    public async Task<CanvasActionInvokeResult> InvokeAsync(string instanceId, string actionName, object? input = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(instanceId);
        ArgumentNullException.ThrowIfNull(actionName);
        _session.ThrowIfDisposed();

        var request = new CanvasActionInvokeRequest { SessionId = _session.SessionId, InstanceId = instanceId, ActionName = actionName, Input = CopilotClient.ToJsonElementForWire(input) };
        return await CopilotClient.InvokeRpcAsync<CanvasActionInvokeResult>(_session.Rpc, "session.canvas.action.invoke", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped CanvasProvider APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CanvasProviderApi
{
    private readonly CopilotSession _session;

    internal CanvasProviderApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Registers an internal canvas provider connection and its contributions.</summary>
    /// <param name="connectionId">Connection identifier for callback routing.</param>
    /// <param name="info">Provider metadata supplied by the host.</param>
    /// <param name="canvases">Canvas contributions supplied by the provider.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task RegisterAsync(string connectionId, object info, IList<object?> canvases, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(connectionId);
        ArgumentNullException.ThrowIfNull(info);
        ArgumentNullException.ThrowIfNull(canvases);
        _session.ThrowIfDisposed();

        var request = new CanvasProviderRegisterRequest { SessionId = _session.SessionId, ConnectionId = connectionId, Info = CopilotClient.ToJsonElementForWire(info)!.Value, Canvases = canvases.Select(static v => CopilotClient.ToJsonElementForWire(v)!.Value).ToList() };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.canvas.provider.register", [request], cancellationToken);
    }

    /// <summary>Unregisters an internal canvas provider connection.</summary>
    /// <param name="connectionId">Connection identifier to unregister.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task UnregisterAsync(string connectionId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(connectionId);
        _session.ThrowIfDisposed();

        var request = new CanvasProviderUnregisterRequest { SessionId = _session.SessionId, ConnectionId = connectionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.canvas.provider.unregister", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Factory APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryApi
{
    private readonly CopilotSession _session;

    internal FactoryApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Runs a registered factory by name at the top level.</summary>
    /// <param name="name">Registered factory name.</param>
    /// <param name="args">Factory input value.</param>
    /// <param name="options">Factory invocation options.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Complete current or terminal factory run envelope.</returns>
    public async Task<FactoryRunResult> RunAsync(string name, object args, RunOptions? options = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        ArgumentNullException.ThrowIfNull(args);
        _session.ThrowIfDisposed();

        var request = new FactoryRunRequest { SessionId = _session.SessionId, Name = name, Args = CopilotClient.ToJsonElementForWire(args)!.Value, Options = options };
        return await CopilotClient.InvokeRpcAsync<FactoryRunResult>(_session.Rpc, "session.factory.run", [request], cancellationToken);
    }

    /// <summary>Resumes a factory run using its persisted name, arguments, journal, and accounting.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="limits">Optional per-invocation resource ceiling overrides.</param>
    /// <param name="notifyOnComplete">Whether to notify the originating session when the factory completes.</param>
    /// <param name="logPhaseNames">Whether to emit factory phase names to the session transcript.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Resolved persisted factory identity and resumed run envelope.</returns>
    public async Task<FactoryResumeResult> ResumeAsync(string runId, FactoryRunLimits? limits = null, bool? notifyOnComplete = null, bool? logPhaseNames = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        _session.ThrowIfDisposed();

        var request = new FactoryResumeRequest { SessionId = _session.SessionId, RunId = runId, Limits = limits, NotifyOnComplete = notifyOnComplete, LogPhaseNames = logPhaseNames };
        return await CopilotClient.InvokeRpcAsync<FactoryResumeResult>(_session.Rpc, "session.factory.resume", [request], cancellationToken);
    }

    /// <summary>Internal tool-originated factory invocation.</summary>
    /// <param name="name">Registered factory name.</param>
    /// <param name="args">Factory input value.</param>
    /// <param name="options">Tool-originated factory invocation options.</param>
    /// <param name="toolCallId">Opaque identifier of the originating tool call.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Complete current or terminal factory run envelope.</returns>
    internal async Task<FactoryRunResult> RunFromToolAsync(string name, object args, FactoryToolRunOptions? options = null, string? toolCallId = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        ArgumentNullException.ThrowIfNull(args);
        _session.ThrowIfDisposed();

        var request = new FactoryToolRunRequest { SessionId = _session.SessionId, Name = name, Args = CopilotClient.ToJsonElementForWire(args)!.Value, Options = options, ToolCallId = toolCallId };
        return await CopilotClient.InvokeRpcAsync<FactoryRunResult>(_session.Rpc, "session.factory.runFromTool", [request], cancellationToken);
    }

    /// <summary>Internal tool-originated factory resume.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="limits">Optional per-invocation resource ceiling overrides.</param>
    /// <param name="toolCallId">Opaque identifier of the originating tool call.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Resolved persisted factory identity and resumed run envelope.</returns>
    internal async Task<FactoryResumeResult> ResumeFromToolAsync(string runId, FactoryRunLimits? limits = null, string? toolCallId = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        _session.ThrowIfDisposed();

        var request = new FactoryToolResumeRequest { SessionId = _session.SessionId, RunId = runId, Limits = limits, ToolCallId = toolCallId };
        return await CopilotClient.InvokeRpcAsync<FactoryResumeResult>(_session.Rpc, "session.factory.resumeFromTool", [request], cancellationToken);
    }

    /// <summary>Gets the current or settled envelope for a factory run.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Complete current or terminal factory run envelope.</returns>
    public async Task<FactoryRunResult> GetRunAsync(string runId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        _session.ThrowIfDisposed();

        var request = new FactoryGetRunRequest { SessionId = _session.SessionId, RunId = runId };
        return await CopilotClient.InvokeRpcAsync<FactoryRunResult>(_session.Rpc, "session.factory.getRun", [request], cancellationToken);
    }

    /// <summary>Lists durable factory runs for this session in creation order.</summary>
    /// <param name="afterSeq">Exclusive forward cursor.</param>
    /// <param name="beforeSeq">Exclusive backward cursor.</param>
    /// <param name="limit">Maximum terminal runs to return. Defaults to 200 and is capped at 500.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>A page of factory runs in durable creation order.</returns>
    public async Task<FactoryListRunsResult> ListRunsAsync(long? afterSeq = null, long? beforeSeq = null, int? limit = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new FactoryListRunsRequest { SessionId = _session.SessionId, AfterSeq = afterSeq, BeforeSeq = beforeSeq, Limit = limit };
        return await CopilotClient.InvokeRpcAsync<FactoryListRunsResult>(_session.Rpc, "session.factory.listRuns", [request], cancellationToken);
    }

    /// <summary>Gets durable and live observability detail for one factory run.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Full factory run observability detail.</returns>
    public async Task<FactoryRunDetail> GetRunDetailAsync(string runId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        _session.ThrowIfDisposed();

        var request = new FactoryGetRunRequest { SessionId = _session.SessionId, RunId = runId };
        return await CopilotClient.InvokeRpcAsync<FactoryRunDetail>(_session.Rpc, "session.factory.getRunDetail", [request], cancellationToken);
    }

    /// <summary>Pages durable progress for one factory run.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="phaseId">Optional phase identifier used to scope records and cursors.</param>
    /// <param name="afterSeq">Exclusive forward cursor.</param>
    /// <param name="beforeSeq">Exclusive backward cursor.</param>
    /// <param name="limit">Maximum records to return. Defaults to 200 and is capped at 500.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>A bidirectional page of factory progress.</returns>
    public async Task<FactoryProgressPage> GetRunProgressAsync(string runId, string? phaseId = null, long? afterSeq = null, long? beforeSeq = null, int? limit = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        _session.ThrowIfDisposed();

        var request = new FactoryGetRunProgressRequest { SessionId = _session.SessionId, RunId = runId, PhaseId = phaseId, AfterSeq = afterSeq, BeforeSeq = beforeSeq, Limit = limit };
        return await CopilotClient.InvokeRpcAsync<FactoryProgressPage>(_session.Rpc, "session.factory.getRunProgress", [request], cancellationToken);
    }

    /// <summary>Requests cancellation of a factory run and returns its run envelope.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Complete current or terminal factory run envelope.</returns>
    public async Task<FactoryRunResult> CancelAsync(string runId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        _session.ThrowIfDisposed();

        var request = new FactoryCancelRequest { SessionId = _session.SessionId, RunId = runId };
        return await CopilotClient.InvokeRpcAsync<FactoryRunResult>(_session.Rpc, "session.factory.cancel", [request], cancellationToken);
    }

    /// <summary>Pauses a running factory and returns its settled run envelope.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Complete current or terminal factory run envelope.</returns>
    public async Task<FactoryRunResult> PauseAsync(string runId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        _session.ThrowIfDisposed();

        var request = new FactoryPauseRequest { SessionId = _session.SessionId, RunId = runId };
        return await CopilotClient.InvokeRpcAsync<FactoryRunResult>(_session.Rpc, "session.factory.pause", [request], cancellationToken);
    }

    /// <summary>Atomically pauses an owned factory attempt at a durable checkpoint.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="executionToken">Opaque token identifying the execution attempt that reached the checkpoint.</param>
    /// <param name="key">Stable author-defined checkpoint key.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task<SessionFactoryPauseAtCheckpointResult> PauseAtCheckpointAsync(string runId, string executionToken, string key, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        ArgumentNullException.ThrowIfNull(executionToken);
        ArgumentNullException.ThrowIfNull(key);
        _session.ThrowIfDisposed();

        var request = new FactoryPauseCheckpointRequest { SessionId = _session.SessionId, RunId = runId, ExecutionToken = executionToken, Key = key };
        return await CopilotClient.InvokeRpcAsync<SessionFactoryPauseAtCheckpointResult>(_session.Rpc, "session.factory.pauseAtCheckpoint", [request], cancellationToken);
    }

    /// <summary>Records a batch of ordered factory progress lines.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="executionToken">Opaque token identifying the current factory execution attempt.</param>
    /// <param name="lines">Ordered progress lines to append.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Acknowledgement that a factory request was accepted.</returns>
    public async Task<FactoryAckResult> LogAsync(string runId, string executionToken, IList<FactoryLogLine> lines, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        ArgumentNullException.ThrowIfNull(executionToken);
        ArgumentNullException.ThrowIfNull(lines);
        _session.ThrowIfDisposed();

        var request = new FactoryLogRequest { SessionId = _session.SessionId, RunId = runId, ExecutionToken = executionToken, Lines = lines };
        return await CopilotClient.InvokeRpcAsync<FactoryAckResult>(_session.Rpc, "session.factory.log", [request], cancellationToken);
    }

    /// <summary>Runs one factory-scoped subagent and returns its result.</summary>
    /// <param name="factoryRunId">Factory run identifier that owns the subagent.</param>
    /// <param name="executionToken">Opaque token identifying the current factory execution attempt.</param>
    /// <param name="prompt">Prompt to send to the subagent.</param>
    /// <param name="opts">Subagent execution options.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of one factory-scoped subagent call.</returns>
    public async Task<FactoryAgentResult> AgentAsync(string factoryRunId, string executionToken, string prompt, FactoryAgentOptions opts, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(factoryRunId);
        ArgumentNullException.ThrowIfNull(executionToken);
        ArgumentNullException.ThrowIfNull(prompt);
        ArgumentNullException.ThrowIfNull(opts);
        _session.ThrowIfDisposed();

        var request = new FactoryAgentRequest { SessionId = _session.SessionId, FactoryRunId = factoryRunId, ExecutionToken = executionToken, Prompt = prompt, Opts = opts };
        return await CopilotClient.InvokeRpcAsync<FactoryAgentResult>(_session.Rpc, "session.factory.agent", [request], cancellationToken);
    }

    /// <summary>Journal APIs.</summary>
    public FactoryJournalApi Journal =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;
}

/// <summary>Provides session-scoped FactoryJournal APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FactoryJournalApi
{
    private readonly CopilotSession _session;

    internal FactoryJournalApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Reads a memoized factory journal entry.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="executionToken">Opaque token identifying the current factory execution attempt.</param>
    /// <param name="key">Namespaced journal key.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of reading a factory journal entry.</returns>
    public async Task<FactoryJournalGetResult> GetAsync(string runId, string executionToken, string key, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        ArgumentNullException.ThrowIfNull(executionToken);
        ArgumentNullException.ThrowIfNull(key);
        _session.ThrowIfDisposed();

        var request = new FactoryJournalGetRequest { SessionId = _session.SessionId, RunId = runId, ExecutionToken = executionToken, Key = key };
        return await CopilotClient.InvokeRpcAsync<FactoryJournalGetResult>(_session.Rpc, "session.factory.journal.get", [request], cancellationToken);
    }

    /// <summary>Stores a memoized factory journal entry.</summary>
    /// <param name="runId">Factory run identifier.</param>
    /// <param name="executionToken">Opaque token identifying the current factory execution attempt.</param>
    /// <param name="key">Namespaced journal key.</param>
    /// <param name="resultJson">JSON result to memoize.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Acknowledgement that a factory request was accepted.</returns>
    public async Task<FactoryAckResult> PutAsync(string runId, string executionToken, string key, object resultJson, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(runId);
        ArgumentNullException.ThrowIfNull(executionToken);
        ArgumentNullException.ThrowIfNull(key);
        ArgumentNullException.ThrowIfNull(resultJson);
        _session.ThrowIfDisposed();

        var request = new FactoryJournalPutRequest { SessionId = _session.SessionId, RunId = runId, ExecutionToken = executionToken, Key = key, ResultJson = CopilotClient.ToJsonElementForWire(resultJson)!.Value };
        return await CopilotClient.InvokeRpcAsync<FactoryAckResult>(_session.Rpc, "session.factory.journal.put", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Model APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModelApi
{
    private readonly CopilotSession _session;

    internal ModelApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets the session's authoritative model snapshot, including the committed Auto preference and any newer unclaimed Auto preference waiting for a future user turn.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The session's authoritative model snapshot. Auto preference fields are configuration for the virtual `auto` model and do not change the selected model identifier. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.</returns>
    public async Task<CurrentModel> GetCurrentAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionModelGetCurrentRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<CurrentModel>(_session.Rpc, "session.model.getCurrent", [request], cancellationToken);
    }

    /// <summary>Switches the session to a model and optional reasoning configuration.</summary>
    /// <param name="modelId">Model selection id to switch to, as returned by `list`. A bare id (e.g. `claude-sonnet-4.6`) names a Copilot (CAPI) model; a provider-qualified id (`provider/id`, e.g. `acme/claude-sonnet`) targets a registry BYOK model.</param>
    /// <param name="autoTier">Optional Auto routing preference to stage atomically with selecting `auto`. Pass null to return to provider-default Auto routing. This field is rejected when `modelId` is not `auto`.</param>
    /// <param name="reasoningEffort">Reasoning effort level to use for the model. CAPI values are model-defined and validated against the selected model; BYOK providers may define additional values. "none" disables reasoning. When omitted, no effort override is applied.</param>
    /// <param name="reasoningSummary">Reasoning summary mode to request for supported model clients.</param>
    /// <param name="verbosity">Output verbosity level to request for supported models.</param>
    /// <param name="modelCapabilities">Override individual model capabilities resolved by the runtime.</param>
    /// <param name="contextTier">Explicit context tier for the selected model. `"default"` / `"long_context"` apply the requested tier; omit this field to use normal model behavior with no explicit tier.</param>
    /// <param name="source">Origin to record on the effective `session.model_change` event for trusted in-process calls. Transport SDK calls are always recorded as `sdk`, regardless of this value.</param>
    /// <param name="deferIfModelChangeQueued">When true, defer this switch (enqueue it) if another model change is already queued, even when no turn is active — so it drains last (FIFO) and wins over the already-queued change. Intended for genuine user-initiated model selections; internal restore/reapply switches omit it and apply immediately when no turn is active. When no other model change is queued this has no effect (a switch still applies immediately unless a turn is active).</param>
    /// <param name="compactionDecision">Explicit response to a model-switch compaction preflight. Omit to request a confirmation projection when compaction is necessary.</param>
    /// <param name="runCompactionPreflight">When true, evaluate context-window compaction policy before applying the switch.</param>
    /// <param name="repoScope">Optional repository settings scope to persist after the switch commits.</param>
    /// <param name="modelChangeScope">Settings scope used when persisting the selected model.</param>
    /// <param name="requireAvailable">Require the target to be currently available and enabled before applying the switch.</param>
    /// <param name="pickerPersistence">Optional settings context and explicit-override flags used to persist a picker selection.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The model identifier active on the session after the switch.</returns>
    public async Task<ModelSwitchToResult> SwitchToAsync(string modelId, AutoTier? autoTier = null, string? reasoningEffort = null, ReasoningSummary? reasoningSummary = null, Verbosity? verbosity = null, ModelCapabilitiesOverride? modelCapabilities = null, ContextTier? contextTier = null, ModelChangeSource? source = null, bool? deferIfModelChangeQueued = null, string? compactionDecision = null, bool? runCompactionPreflight = null, string? repoScope = null, string? modelChangeScope = null, bool? requireAvailable = null, ModelPickerPersistenceRequest? pickerPersistence = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(modelId);
        _session.ThrowIfDisposed();

        var request = new ModelSwitchToRequest { SessionId = _session.SessionId, ModelId = modelId, AutoTier = autoTier, ReasoningEffort = reasoningEffort, ReasoningSummary = reasoningSummary, Verbosity = verbosity, ModelCapabilities = modelCapabilities, ContextTier = contextTier, Source = source, DeferIfModelChangeQueued = deferIfModelChangeQueued, CompactionDecision = compactionDecision, RunCompactionPreflight = runCompactionPreflight, RepoScope = repoScope, ModelChangeScope = modelChangeScope, RequireAvailable = requireAvailable, PickerPersistence = pickerPersistence };
        return await CopilotClient.InvokeRpcAsync<ModelSwitchToResult>(_session.Rpc, "session.model.switchTo", [request], cancellationToken);
    }

    /// <summary>Requests an Auto preference change without changing the session's selected model. The latest unclaimed request wins; the runtime commits it only after a later prompt using the `auto` model mints a usable model and token pair. A `pending` response confirms that the request was accepted, not that it committed. Observe eventual success through `session.model_change`, failure through the ephemeral `session.auto_tier_switch_failed` event, or current unclaimed state through `session.model.getCurrent`.</summary>
    /// <param name="autoTier">Auto preference to activate when a future user turn using the `auto` model safely mints a replacement model and token pair. Pass null to return to provider-default Auto routing.</param>
    /// <param name="source">Origin to record on the effective `session.model_change` event. Defaults to `sdk` when omitted.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Immediate acknowledgement and Auto preference snapshot after a switch request. This result never implies that a pending preference committed.</returns>
    public async Task<ModelSwitchAutoTierResult> SwitchAutoTierAsync(AutoTier? autoTier, ModelChangeSource? source = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ModelSwitchAutoTierRequest { SessionId = _session.SessionId, AutoTier = autoTier, Source = source };
        return await CopilotClient.InvokeRpcAsync<ModelSwitchAutoTierResult>(_session.Rpc, "session.model.switchAutoTier", [request], cancellationToken);
    }

    /// <summary>Resolves and applies organization-managed and repository model overlays.</summary>
    /// <param name="deviceManagedModel">Model required by device-managed policy, when configured.</param>
    /// <param name="serverManagedModel">Model required by server-managed policy, when configured.</param>
    /// <param name="policyHelperModel">Startup default model from the enterprise policy helper, when configured. Weakest of the managed sources: it applies only when neither device nor server policy names a model, and an explicit user selection still wins.</param>
    /// <param name="repoModel">Model selected by repository settings, when configured.</param>
    /// <param name="repoReasoningEffort">Reasoning effort selected by repository settings, when configured.</param>
    /// <param name="repoContextTier">Context tier selected by repository settings, when configured.</param>
    /// <param name="cliModel">Model explicitly selected by the CLI, when provided.</param>
    /// <param name="deferredResume">Whether the overlay is being applied while resuming a deferred session.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The model identifier active on the session after the switch.</returns>
    internal async Task<ModelSwitchToResult> ApplyStartupOverlayAsync(string? deviceManagedModel = null, string? serverManagedModel = null, string? policyHelperModel = null, string? repoModel = null, string? repoReasoningEffort = null, string? repoContextTier = null, string? cliModel = null, bool? deferredResume = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ModelApplyStartupOverlayRequest { SessionId = _session.SessionId, DeviceManagedModel = deviceManagedModel, ServerManagedModel = serverManagedModel, PolicyHelperModel = policyHelperModel, RepoModel = repoModel, RepoReasoningEffort = repoReasoningEffort, RepoContextTier = repoContextTier, CliModel = cliModel, DeferredResume = deferredResume };
        return await CopilotClient.InvokeRpcAsync<ModelSwitchToResult>(_session.Rpc, "session.model.applyStartupOverlay", [request], cancellationToken);
    }

    /// <summary>Replaces or clears the host-supplied model allowlist for a running session.</summary>
    /// <param name="allowedModels">Exact model IDs to permit, or null to clear the host restriction.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The applied host allowlist and effective session model policy after intersection.</returns>
    public async Task<ModelSetAllowedModelsResult> SetAllowedModelsAsync(IList<string>? allowedModels = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ModelSetAllowedModelsRequest { SessionId = _session.SessionId, AllowedModels = allowedModels };
        return await CopilotClient.InvokeRpcAsync<ModelSetAllowedModelsResult>(_session.Rpc, "session.model.setAllowedModels", [request], cancellationToken);
    }

    /// <summary>Updates the session's reasoning effort without changing the selected model.</summary>
    /// <param name="reasoningEffort">Reasoning effort level to apply to the currently selected model. The host is responsible for validating the value against the model's supported levels before calling.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Update the session's reasoning effort without changing the selected model. Use `switchTo` instead when you also need to change the model. The runtime stores the effort on the session and applies it to subsequent turns.</returns>
    public async Task<ModelSetReasoningEffortResult> SetReasoningEffortAsync(string reasoningEffort, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(reasoningEffort);
        _session.ThrowIfDisposed();

        var request = new ModelSetReasoningEffortRequest { SessionId = _session.SessionId, ReasoningEffort = reasoningEffort };
        return await CopilotClient.InvokeRpcAsync<ModelSetReasoningEffortResult>(_session.Rpc, "session.model.setReasoningEffort", [request], cancellationToken);
    }

    /// <summary>Lists models available to this session using its own auth and integration context. Connected hosts (CLI TUI, GitHub App) should call this through the session client so remote sessions return the remote CLI's available models rather than the caller's.</summary>
    /// <param name="request">Optional listing options.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The list of models available to this session.</returns>
    public async Task<SessionModelList> ListAsync(SessionModelListRequest? request = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var rpcRequest = new SessionModelListRequestWithSession { SessionId = _session.SessionId, SkipCache = request?.SkipCache };
        return await CopilotClient.InvokeRpcAsync<SessionModelList>(_session.Rpc, "session.model.list", [rpcRequest], cancellationToken);
    }
}

/// <summary>Provides session-scoped Mode APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ModeApi
{
    private readonly CopilotSession _session;

    internal ModeApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets the current agent interaction mode.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The session mode the agent is operating in.</returns>
    public async Task<SessionMode> GetAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionModeGetRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SessionMode>(_session.Rpc, "session.mode.get", [request], cancellationToken);
    }

    /// <summary>Sets the current agent interaction mode.</summary>
    /// <param name="mode">The session mode the agent is operating in.</param>
    /// <param name="inheritPlanBaseFromSessionId">Session whose plan-mode base state should be inherited.</param>
    /// <param name="planModelConfigured">Whether a dedicated plan model is configured.</param>
    /// <param name="planModel">Dedicated model to use in plan mode, when configured.</param>
    /// <param name="planReasoningEffort">Reasoning effort to use with the dedicated plan model.</param>
    /// <param name="planContextTier">Context tier to use with the dedicated plan model.</param>
    /// <param name="compactionDecision">Explicit response to a model-switch compaction preflight.</param>
    /// <param name="restorePlanModel">Whether leaving plan mode should restore the session's previous model.</param>
    /// <param name="persistPlanSelection">Whether the selected plan model should be persisted.</param>
    /// <param name="pickerSettingsContext">Settings context used when persisting the selected plan model.</param>
    /// <param name="planExitAction">Action to perform when leaving plan mode.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of a session mode change, including any model switch it triggered and follow-up the host must perform.</returns>
    public async Task<ModeSetResult> SetAsync(SessionMode mode, string? inheritPlanBaseFromSessionId = null, bool? planModelConfigured = null, string? planModel = null, string? planReasoningEffort = null, string? planContextTier = null, string? compactionDecision = null, bool? restorePlanModel = null, bool? persistPlanSelection = null, ModelPickerSettingsContext? pickerSettingsContext = null, string? planExitAction = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ModeSetRequest { SessionId = _session.SessionId, Mode = mode, InheritPlanBaseFromSessionId = inheritPlanBaseFromSessionId, PlanModelConfigured = planModelConfigured, PlanModel = planModel, PlanReasoningEffort = planReasoningEffort, PlanContextTier = planContextTier, CompactionDecision = compactionDecision, RestorePlanModel = restorePlanModel, PersistPlanSelection = persistPlanSelection, PickerSettingsContext = pickerSettingsContext, PlanExitAction = planExitAction };
        return await CopilotClient.InvokeRpcAsync<ModeSetResult>(_session.Rpc, "session.mode.set", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Name APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class NameApi
{
    private readonly CopilotSession _session;

    internal NameApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets the session's friendly name.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The session's friendly name, or null when not yet set.</returns>
    public async Task<NameGetResult> GetAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionNameGetRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<NameGetResult>(_session.Rpc, "session.name.get", [request], cancellationToken);
    }

    /// <summary>Sets the session's friendly name.</summary>
    /// <param name="name">New session name (1–100 characters, trimmed of leading/trailing whitespace).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetAsync(string name, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        _session.ThrowIfDisposed();

        var request = new NameSetRequest { SessionId = _session.SessionId, Name = name };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.name.set", [request], cancellationToken);
    }

    /// <summary>Persists an auto-generated session summary as the session's name when no user-set name exists.</summary>
    /// <param name="summary">Auto-generated session summary. Empty/whitespace-only values are ignored; values are trimmed before persisting.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the auto-generated summary was applied as the session's name.</returns>
    public async Task<NameSetAutoResult> SetAutoAsync(string summary, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(summary);
        _session.ThrowIfDisposed();

        var request = new NameSetAutoRequest { SessionId = _session.SessionId, Summary = summary };
        return await CopilotClient.InvokeRpcAsync<NameSetAutoResult>(_session.Rpc, "session.name.setAuto", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Plan APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PlanApi
{
    private readonly CopilotSession _session;

    internal PlanApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Reads the session plan file from the workspace.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Existence, contents, and resolved path of the session plan file.</returns>
    public async Task<PlanReadResult> ReadAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionPlanReadRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<PlanReadResult>(_session.Rpc, "session.plan.read", [request], cancellationToken);
    }

    /// <summary>Writes new content to the session plan file.</summary>
    /// <param name="content">The new content for the plan file.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task UpdateAsync(string content, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(content);
        _session.ThrowIfDisposed();

        var request = new PlanUpdateRequest { SessionId = _session.SessionId, Content = content };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.plan.update", [request], cancellationToken);
    }

    /// <summary>Deletes the session plan file from the workspace.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DeleteAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionPlanDeleteRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.plan.delete", [request], cancellationToken);
    }

    /// <summary>Reads todo rows from the session SQL database for plan rendering.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Todo rows read from the session SQL database. Empty when no session database is available.</returns>
    public async Task<PlanReadSqlTodosResult> ReadSqlTodosAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionPlanReadSqlTodosRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<PlanReadSqlTodosResult>(_session.Rpc, "session.plan.readSqlTodos", [request], cancellationToken);
    }

    /// <summary>Reads todo rows AND dependency edges from the session SQL database for structured progress UI. Same defensive behavior as readSqlTodos — returns empty arrays when the database, tables, or columns aren't available. Clients should call this on session start and after every `session.todos_changed` event to refresh structured-UI rendering.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Todo rows + dependency edges read from the session SQL database.</returns>
    public async Task<PlanReadSqlTodosWithDependenciesResult> ReadSqlTodosWithDependenciesAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionPlanReadSqlTodosWithDependenciesRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<PlanReadSqlTodosWithDependenciesResult>(_session.Rpc, "session.plan.readSqlTodosWithDependencies", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Workspaces APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class WorkspacesApi
{
    private readonly CopilotSession _session;

    internal WorkspacesApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets current workspace metadata for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current workspace metadata for the session, including its absolute filesystem path when available.</returns>
    public async Task<WorkspacesGetWorkspaceResult> GetWorkspaceAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionWorkspacesGetWorkspaceRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<WorkspacesGetWorkspaceResult>(_session.Rpc, "session.workspaces.getWorkspace", [request], cancellationToken);
    }

    /// <summary>Updates workspace metadata for a local session and returns the refreshed workspace.</summary>
    /// <param name="context">Opaque workspace context supplied by the session host.</param>
    /// <param name="name">Optional workspace display name override.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current workspace metadata for the session, including its absolute filesystem path when available.</returns>
    public async Task<WorkspacesGetWorkspaceResult> UpdateMetadataAsync(object? context = null, string? name = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new WorkspacesUpdateMetadataRequest { SessionId = _session.SessionId, Context = CopilotClient.ToJsonElementForWire(context), Name = name };
        return await CopilotClient.InvokeRpcAsync<WorkspacesGetWorkspaceResult>(_session.Rpc, "session.workspaces.updateMetadata", [request], cancellationToken);
    }

    /// <summary>Ensures a local session workspace exists and returns it.</summary>
    /// <param name="context">Opaque workspace context supplied by the session host.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current workspace metadata for the session, including its absolute filesystem path when available.</returns>
    public async Task<WorkspacesGetWorkspaceResult> EnsureAsync(object? context = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new WorkspacesEnsureRequest { SessionId = _session.SessionId, Context = CopilotClient.ToJsonElementForWire(context) };
        return await CopilotClient.InvokeRpcAsync<WorkspacesGetWorkspaceResult>(_session.Rpc, "session.workspaces.ensure", [request], cancellationToken);
    }

    /// <summary>Lists files stored in the session workspace files directory.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Relative paths of files stored in the session workspace files directory.</returns>
    public async Task<WorkspacesListFilesResult> ListFilesAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionWorkspacesListFilesRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<WorkspacesListFilesResult>(_session.Rpc, "session.workspaces.listFiles", [request], cancellationToken);
    }

    /// <summary>Reads a file from the session workspace files directory.</summary>
    /// <param name="path">Relative path within the workspace files directory.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Contents of the requested workspace file as a UTF-8 string.</returns>
    public async Task<WorkspacesReadFileResult> ReadFileAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        _session.ThrowIfDisposed();

        var request = new WorkspacesReadFileRequest { SessionId = _session.SessionId, Path = path };
        return await CopilotClient.InvokeRpcAsync<WorkspacesReadFileResult>(_session.Rpc, "session.workspaces.readFile", [request], cancellationToken);
    }

    /// <summary>Creates or overwrites a file in the session workspace files directory.</summary>
    /// <param name="path">Relative path within the workspace files directory.</param>
    /// <param name="content">File content to write as a UTF-8 string.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task CreateFileAsync(string path, string content, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        ArgumentNullException.ThrowIfNull(content);
        _session.ThrowIfDisposed();

        var request = new WorkspacesCreateFileRequest { SessionId = _session.SessionId, Path = path, Content = content };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.workspaces.createFile", [request], cancellationToken);
    }

    /// <summary>Lists workspace checkpoints in chronological order.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Workspace checkpoints in chronological order; empty when the workspace is not enabled.</returns>
    public async Task<WorkspacesListCheckpointsResult> ListCheckpointsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionWorkspacesListCheckpointsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<WorkspacesListCheckpointsResult>(_session.Rpc, "session.workspaces.listCheckpoints", [request], cancellationToken);
    }

    /// <summary>Reads the content of a workspace checkpoint by number.</summary>
    /// <param name="number">Checkpoint number to read.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Checkpoint content as a UTF-8 string, or null when the checkpoint or workspace is missing.</returns>
    public async Task<WorkspacesReadCheckpointResult> ReadCheckpointAsync(long number, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new WorkspacesReadCheckpointRequest { SessionId = _session.SessionId, Number = number };
        return await CopilotClient.InvokeRpcAsync<WorkspacesReadCheckpointResult>(_session.Rpc, "session.workspaces.readCheckpoint", [request], cancellationToken);
    }

    /// <summary>Adds a compaction summary checkpoint to the local session workspace.</summary>
    /// <param name="title">Summary title shown in checkpoint listings.</param>
    /// <param name="content">Markdown summary content to persist.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Persisted summary metadata and refreshed workspace metadata.</returns>
    public async Task<WorkspacesAddSummaryResult> AddSummaryAsync(string title, string content, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(title);
        ArgumentNullException.ThrowIfNull(content);
        _session.ThrowIfDisposed();

        var request = new WorkspacesAddSummaryRequest { SessionId = _session.SessionId, Title = title, Content = content };
        return await CopilotClient.InvokeRpcAsync<WorkspacesAddSummaryResult>(_session.Rpc, "session.workspaces.addSummary", [request], cancellationToken);
    }

    /// <summary>Truncates local workspace compaction summaries after a rollback.</summary>
    /// <param name="keepCount">Number of newest summaries to keep.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current workspace metadata for the session, including its absolute filesystem path when available.</returns>
    public async Task<WorkspacesGetWorkspaceResult> TruncateSummariesAsync(long keepCount, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new WorkspacesTruncateSummariesRequest { SessionId = _session.SessionId, KeepCount = keepCount };
        return await CopilotClient.InvokeRpcAsync<WorkspacesGetWorkspaceResult>(_session.Rpc, "session.workspaces.truncateSummaries", [request], cancellationToken);
    }

    /// <summary>Reads the autopilot objective state file from the local session workspace.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Autopilot objective file content, or null when missing.</returns>
    public async Task<WorkspacesReadAutopilotObjectiveResult> ReadAutopilotObjectiveAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionWorkspacesReadAutopilotObjectiveRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<WorkspacesReadAutopilotObjectiveResult>(_session.Rpc, "session.workspaces.readAutopilotObjective", [request], cancellationToken);
    }

    /// <summary>Writes the autopilot objective state file in the local session workspace.</summary>
    /// <param name="content">Autopilot objective file content.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of writing the autopilot objective file.</returns>
    public async Task<WorkspacesWriteAutopilotObjectiveResult> WriteAutopilotObjectiveAsync(string content, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(content);
        _session.ThrowIfDisposed();

        var request = new WorkspacesWriteAutopilotObjectiveRequest { SessionId = _session.SessionId, Content = content };
        return await CopilotClient.InvokeRpcAsync<WorkspacesWriteAutopilotObjectiveResult>(_session.Rpc, "session.workspaces.writeAutopilotObjective", [request], cancellationToken);
    }

    /// <summary>Deletes the autopilot objective state file from the local session workspace.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of deleting the autopilot objective file.</returns>
    public async Task<WorkspacesDeleteAutopilotObjectiveResult> DeleteAutopilotObjectiveAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionWorkspacesDeleteAutopilotObjectiveRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<WorkspacesDeleteAutopilotObjectiveResult>(_session.Rpc, "session.workspaces.deleteAutopilotObjective", [request], cancellationToken);
    }

    /// <summary>Checks whether the local session workspace has an autopilot objective state file.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the autopilot objective file exists.</returns>
    public async Task<WorkspacesAutopilotObjectiveExistsResult> AutopilotObjectiveExistsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionWorkspacesAutopilotObjectiveExistsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<WorkspacesAutopilotObjectiveExistsResult>(_session.Rpc, "session.workspaces.autopilotObjectiveExists", [request], cancellationToken);
    }

    /// <summary>Saves pasted content as a UTF-8 file in the session workspace.</summary>
    /// <param name="content">Pasted content to save as a UTF-8 file.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Descriptor for the saved paste file, or null when the workspace is unavailable.</returns>
    public async Task<WorkspacesSaveLargePasteResult> SaveLargePasteAsync(string content, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(content);
        _session.ThrowIfDisposed();

        var request = new WorkspacesSaveLargePasteRequest { SessionId = _session.SessionId, Content = content };
        return await CopilotClient.InvokeRpcAsync<WorkspacesSaveLargePasteResult>(_session.Rpc, "session.workspaces.saveLargePaste", [request], cancellationToken);
    }

    /// <summary>Computes a diff for the session workspace. Never rejects for a busy session: a `session`-mode diff that cannot read the session's file-change captures falls back to an unstaged git diff with `isFallback: true` and reports why in `unavailableReason`.</summary>
    /// <param name="mode">Diff mode requested by the client.</param>
    /// <param name="ignoreWhitespace">When true, ignore whitespace-only changes (git `--ignore-all-space`). Defaults to false.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Workspace diff result for the requested mode.</returns>
    public async Task<WorkspaceDiffResult> DiffAsync(WorkspaceDiffMode mode, bool? ignoreWhitespace = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new WorkspacesDiffRequest { SessionId = _session.SessionId, Mode = mode, IgnoreWhitespace = ignoreWhitespace };
        return await CopilotClient.InvokeRpcAsync<WorkspaceDiffResult>(_session.Rpc, "session.workspaces.diff", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped AutopilotObjective APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AutopilotObjectiveApi
{
    private readonly CopilotSession _session;

    internal AutopilotObjectiveApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Reads the current canonical autopilot objective state for this session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Canonical runtime state for the session's current autopilot objective.</returns>
    public async Task<AutopilotObjectiveGetStateResult> GetStateAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionAutopilotObjectiveGetStateRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<AutopilotObjectiveGetStateResult>(_session.Rpc, "session.autopilotObjective.getState", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Completions APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CompletionsApi
{
    private readonly CopilotSession _session;

    internal CompletionsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets the characters that should trigger host-driven completions for the session. Empty disables host-driven completions (e.g. local sessions, or a relay host that does not advertise them).</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Characters that, when typed in the composer, should trigger a `completions.request`. Empty when the session has no host-driven completions (e.g. local sessions, or a relay host that does not advertise `completionTriggerCharacters`).</returns>
    public async Task<CompletionsGetTriggerCharactersResult> GetTriggerCharactersAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionCompletionsGetTriggerCharactersRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<CompletionsGetTriggerCharactersResult>(_session.Rpc, "session.completions.getTriggerCharacters", [request], cancellationToken);
    }

    /// <summary>Requests host-driven completion items for the current composer input. Returns an empty list when the host has no items or does not support completions.</summary>
    /// <param name="text">The full composed composer input.</param>
    /// <param name="offset">Cursor offset within `text`, in UTF-16 code units.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Host-driven completion items for the current composer input. Empty when the host returns no items or does not support completions.</returns>
    public async Task<CompletionsRequestResult> RequestAsync(string text, long offset, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(text);
        _session.ThrowIfDisposed();

        var request = new CompletionsRequestRequest { SessionId = _session.SessionId, Text = text, Offset = offset };
        return await CopilotClient.InvokeRpcAsync<CompletionsRequestResult>(_session.Rpc, "session.completions.request", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Instructions APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class InstructionsApi
{
    private readonly CopilotSession _session;

    internal InstructionsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets instruction sources loaded for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Instruction sources loaded for the session, in merge order.</returns>
    public async Task<InstructionsGetSourcesResult> GetSourcesAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionInstructionsGetSourcesRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<InstructionsGetSourcesResult>(_session.Rpc, "session.instructions.getSources", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Fleet APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class FleetApi
{
    private readonly CopilotSession _session;

    internal FleetApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Starts fleet mode by submitting the fleet orchestration prompt to the session.</summary>
    /// <param name="prompt">Optional user prompt to combine with fleet instructions.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether fleet mode was successfully activated.</returns>
    public async Task<FleetStartResult> StartAsync(string? prompt = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new FleetStartRequest { SessionId = _session.SessionId, Prompt = prompt };
        return await CopilotClient.InvokeRpcAsync<FleetStartResult>(_session.Rpc, "session.fleet.start", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Agent APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class AgentApi
{
    private readonly CopilotSession _session;

    internal AgentApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists agents available to the session. Defaults to custom agents only; pass includeBuiltInAgents to include the effective built-in agents.</summary>
    /// <param name="request">Controls whether built-in agents and authored prompt text are included.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Agents available to the session.</returns>
    public async Task<AgentList> ListAsync(SessionAgentListRequest? request = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var rpcRequest = new SessionAgentListRequestWithSession { SessionId = _session.SessionId, IncludeBuiltInAgents = request?.IncludeBuiltInAgents, IncludePrompt = request?.IncludePrompt };
        return await CopilotClient.InvokeRpcAsync<AgentList>(_session.Rpc, "session.agent.list", [rpcRequest], cancellationToken);
    }

    /// <summary>Sets an in-memory authored prompt override for an available agent. For built-in agents, this replaces only the static base prompt while preserving runtime-owned dynamic prompt composition and behavior. The special `general-purpose` agent is not overrideable. Overrides are not persisted; resumed and forked sessions start without them, so the host must re-apply them.</summary>
    /// <param name="id">Stable effective agent id. Plugin namespace separators are normalized.</param>
    /// <param name="prompt">Replacement authored prompt. Empty text is valid.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetPromptAsync(string id, string prompt, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new AgentSetPromptRequest { SessionId = _session.SessionId, Id = id, Prompt = prompt };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.agent.setPrompt", [request], cancellationToken);
    }

    /// <summary>Gets the currently selected custom agent for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The currently selected custom agent, or null when using the default agent.</returns>
    public async Task<AgentGetCurrentResult> GetCurrentAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionAgentGetCurrentRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<AgentGetCurrentResult>(_session.Rpc, "session.agent.getCurrent", [request], cancellationToken);
    }

    /// <summary>Selects a custom agent for subsequent turns in the session.</summary>
    /// <param name="name">Name of the custom agent to select.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The newly selected custom agent.</returns>
    public async Task<AgentSelectResult> SelectAsync(string name, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        _session.ThrowIfDisposed();

        var request = new AgentSelectRequest { SessionId = _session.SessionId, Name = name };
        return await CopilotClient.InvokeRpcAsync<AgentSelectResult>(_session.Rpc, "session.agent.select", [request], cancellationToken);
    }

    /// <summary>Clears the selected custom agent and returns the session to the default agent.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DeselectAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionAgentDeselectRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.agent.deselect", [request], cancellationToken);
    }

    /// <summary>Reloads custom agent definitions and returns the refreshed list.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Custom agents available to the session after reloading definitions from disk.</returns>
    public async Task<AgentReloadResult> ReloadAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionAgentReloadRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<AgentReloadResult>(_session.Rpc, "session.agent.reload", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Tasks APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TasksApi
{
    private readonly CopilotSession _session;

    internal TasksApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Starts a background agent task in the session.</summary>
    /// <param name="agentType">Type of agent to start (e.g., 'explore', 'task', 'general-purpose').</param>
    /// <param name="prompt">Task prompt for the agent.</param>
    /// <param name="name">Friendly, non-unique name used when displaying the agent.</param>
    /// <param name="description">Short description of the task.</param>
    /// <param name="model">Optional model override.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Identifier assigned to the newly started background agent task.</returns>
    public async Task<TasksStartAgentResult> StartAgentAsync(string agentType, string prompt, string name, string? description = null, string? model = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(agentType);
        ArgumentNullException.ThrowIfNull(prompt);
        ArgumentNullException.ThrowIfNull(name);
        _session.ThrowIfDisposed();

        var request = new TasksStartAgentRequest { SessionId = _session.SessionId, AgentType = agentType, Prompt = prompt, Name = name, Description = description, Model = model };
        return await CopilotClient.InvokeRpcAsync<TasksStartAgentResult>(_session.Rpc, "session.tasks.startAgent", [request], cancellationToken);
    }

    /// <summary>Lists background tasks tracked by the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Background tasks currently tracked by the session.</returns>
    public async Task<TaskList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionTasksListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<TaskList>(_session.Rpc, "session.tasks.list", [request], cancellationToken);
    }

    /// <summary>Registers a client-owned task, or reclaims an orphaned task belonging to the same extension principal.</summary>
    /// <param name="type">Task kind.</param>
    /// <param name="clientTaskId">Owner-scoped idempotency key used for registration and reclaim.</param>
    /// <param name="description">Human-readable description of the external work.</param>
    /// <param name="cancellable">Whether the owner supports runtime cancellation requests.</param>
    /// <param name="displayName">Optional short display name for the external work.</param>
    /// <param name="expectedSequence">Expected current sequence for idempotent registration or orphan reclaim.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of registering or reclaiming a client-owned task.</returns>
    public async Task<TasksRegisterResult> RegisterAsync(TaskClientType type, string clientTaskId, string description, bool cancellable, string? displayName = null, long? expectedSequence = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(clientTaskId);
        ArgumentNullException.ThrowIfNull(description);
        _session.ThrowIfDisposed();

        var request = new TasksRegisterRequest { SessionId = _session.SessionId, Type = type, ClientTaskId = clientTaskId, Description = description, Cancellable = cancellable, DisplayName = displayName, ExpectedSequence = expectedSequence };
        return await CopilotClient.InvokeRpcAsync<TasksRegisterResult>(_session.Rpc, "session.tasks.register", [request], cancellationToken);
    }

    /// <summary>Publishes generic progress or a terminal outcome for a client-owned task.</summary>
    /// <param name="id">Canonical runtime-generated task identifier.</param>
    /// <param name="sequence">Owner update sequence to apply.</param>
    /// <param name="update">Progress or terminal update payload.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of publishing a client-owned task update.</returns>
    public async Task<TasksUpdateResult> UpdateAsync(string id, long sequence, TaskClientUpdate update, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        ArgumentNullException.ThrowIfNull(update);
        _session.ThrowIfDisposed();

        var request = new TasksUpdateRequest { SessionId = _session.SessionId, Id = id, Sequence = sequence, Update = update };
        return await CopilotClient.InvokeRpcAsync<TasksUpdateResult>(_session.Rpc, "session.tasks.update", [request], cancellationToken);
    }

    /// <summary>Refreshes metadata for any detached background shells the runtime knows about.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Refresh metadata for any detached background shells the runtime knows about. Use after a long pause to pick up exit/output state for shells running outside the agent loop.</returns>
    public async Task<TasksRefreshResult> RefreshAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionTasksRefreshRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<TasksRefreshResult>(_session.Rpc, "session.tasks.refresh", [request], cancellationToken);
    }

    /// <summary>Waits for all in-flight background tasks and any follow-up turns to settle.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Wait until all in-flight background tasks (agents + shells) and any follow-up turns scheduled by their completions have settled. Returns when the runtime is fully drained or after an internal timeout (default 10 minutes; configurable via COPILOT_TASK_WAIT_TIMEOUT_SECONDS).</returns>
    public async Task<TasksWaitForPendingResult> WaitForPendingAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionTasksWaitForPendingRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<TasksWaitForPendingResult>(_session.Rpc, "session.tasks.waitForPending", [request], cancellationToken);
    }

    /// <summary>Returns progress information for a background task by ID.</summary>
    /// <param name="id">Task identifier (agent ID or shell ID).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Progress information for the task, or null when no task with that ID is tracked.</returns>
    public async Task<TasksGetProgressResult> GetProgressAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new TasksGetProgressRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<TasksGetProgressResult>(_session.Rpc, "session.tasks.getProgress", [request], cancellationToken);
    }

    /// <summary>Returns the first sync-waiting task that can currently be promoted to background mode.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The first sync-waiting task that can currently be promoted to background mode.</returns>
    public async Task<TasksGetCurrentPromotableResult> GetCurrentPromotableAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionTasksGetCurrentPromotableRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<TasksGetCurrentPromotableResult>(_session.Rpc, "session.tasks.getCurrentPromotable", [request], cancellationToken);
    }

    /// <summary>Promotes an eligible synchronously-waited task so it continues running in the background.</summary>
    /// <param name="id">Task identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the task was successfully promoted to background mode.</returns>
    public async Task<TasksPromoteToBackgroundResult> PromoteToBackgroundAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new TasksPromoteToBackgroundRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<TasksPromoteToBackgroundResult>(_session.Rpc, "session.tasks.promoteToBackground", [request], cancellationToken);
    }

    /// <summary>Atomically promotes the first promotable sync-waiting task to background mode and returns it.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The promoted task as it now exists in background mode, omitted if no promotable task was waiting.</returns>
    public async Task<TasksPromoteCurrentToBackgroundResult> PromoteCurrentToBackgroundAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionTasksPromoteCurrentToBackgroundRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<TasksPromoteCurrentToBackgroundResult>(_session.Rpc, "session.tasks.promoteCurrentToBackground", [request], cancellationToken);
    }

    /// <summary>Cancels a background task.</summary>
    /// <param name="id">Task identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the background task was successfully cancelled.</returns>
    public async Task<TasksCancelResult> CancelAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new TasksCancelRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<TasksCancelResult>(_session.Rpc, "session.tasks.cancel", [request], cancellationToken);
    }

    /// <summary>Removes a completed or cancelled background task from tracking.</summary>
    /// <param name="id">Task identifier.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the task was removed. False when the task does not exist or is still running/idle.</returns>
    public async Task<TasksRemoveResult> RemoveAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new TasksRemoveRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<TasksRemoveResult>(_session.Rpc, "session.tasks.remove", [request], cancellationToken);
    }

    /// <summary>Sends a message to a background agent task.</summary>
    /// <param name="id">Agent task identifier.</param>
    /// <param name="message">Message content to send to the agent.</param>
    /// <param name="fromAgentId">Agent ID of the sender, if sent on behalf of another agent.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the message was delivered, with an error message when delivery failed.</returns>
    public async Task<TasksSendMessageResult> SendMessageAsync(string id, string message, string? fromAgentId = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        ArgumentNullException.ThrowIfNull(message);
        _session.ThrowIfDisposed();

        var request = new TasksSendMessageRequest { SessionId = _session.SessionId, Id = id, Message = message, FromAgentId = fromAgentId };
        return await CopilotClient.InvokeRpcAsync<TasksSendMessageResult>(_session.Rpc, "session.tasks.sendMessage", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Skills APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SkillsApi
{
    private readonly CopilotSession _session;

    internal SkillsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists skills available to the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Skills available to the session, with their enabled state.</returns>
    public async Task<SkillList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSkillsListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SkillList>(_session.Rpc, "session.skills.list", [request], cancellationToken);
    }

    /// <summary>Returns the skills that have been invoked during this session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Skills invoked during this session, ordered by invocation time (most recent last).</returns>
    public async Task<SkillsGetInvokedResult> GetInvokedAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSkillsGetInvokedRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SkillsGetInvokedResult>(_session.Rpc, "session.skills.getInvoked", [request], cancellationToken);
    }

    /// <summary>Enables a skill for the session.</summary>
    /// <param name="name">Name of the skill to enable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task EnableAsync(string name, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        _session.ThrowIfDisposed();

        var request = new SkillsEnableRequest { SessionId = _session.SessionId, Name = name };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.skills.enable", [request], cancellationToken);
    }

    /// <summary>Disables a skill for the session.</summary>
    /// <param name="name">Name of the skill to disable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DisableAsync(string name, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        _session.ThrowIfDisposed();

        var request = new SkillsDisableRequest { SessionId = _session.SessionId, Name = name };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.skills.disable", [request], cancellationToken);
    }

    /// <summary>Reloads skill definitions for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Diagnostics from reloading skill definitions, with warnings and errors as separate lists.</returns>
    public async Task<SkillsLoadDiagnostics> ReloadAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSkillsReloadRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SkillsLoadDiagnostics>(_session.Rpc, "session.skills.reload", [request], cancellationToken);
    }

    /// <summary>Ensures the session's skill definitions have been loaded from disk.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task EnsureLoadedAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSkillsEnsureLoadedRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.skills.ensureLoaded", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Mcp APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpApi
{
    private readonly CopilotSession _session;

    internal McpApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists MCP servers configured for the session, their connection status, and host-level state. The host-level state (disabled/filtered servers, failed/needs-auth/pending connections, mcp3p policy, full config) is empty/zero when no MCP host has been initialized for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>MCP servers configured for the session, with their connection status and host-level state.</returns>
    public async Task<McpServerList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMcpListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<McpServerList>(_session.Rpc, "session.mcp.list", [request], cancellationToken);
    }

    /// <summary>Lists the tools exposed by a connected MCP server on this session's host. This performs a live `tools/list` request. Tool UI metadata is returned independently of whether MCP Apps rendering is enabled for the session.</summary>
    /// <param name="serverName">Name of the connected MCP server whose tools to list.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Tools exposed by the connected MCP server. Throws when the server is not connected.</returns>
    public async Task<McpListToolsResult> ListToolsAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpListToolsRequest { SessionId = _session.SessionId, ServerName = serverName };
        return await CopilotClient.InvokeRpcAsync<McpListToolsResult>(_session.Rpc, "session.mcp.listTools", [request], cancellationToken);
    }

    /// <summary>Enables an MCP server for the session.</summary>
    /// <param name="serverName">Name of the MCP server to enable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task EnableAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpEnableRequest { SessionId = _session.SessionId, ServerName = serverName };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.enable", [request], cancellationToken);
    }

    /// <summary>Disables an MCP server for the session.</summary>
    /// <param name="serverName">Name of the MCP server to disable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DisableAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpDisableRequest { SessionId = _session.SessionId, ServerName = serverName };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.disable", [request], cancellationToken);
    }

    /// <summary>Reloads MCP server connections for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ReloadAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMcpReloadRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.reload", [request], cancellationToken);
    }

    /// <summary>Releases any turns waiting on an in-flight MCP load without cancelling the load, letting the agent proceed while MCP servers finish connecting in the background. No-op when no MCP load is in flight or waiting turns were already released.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of moving in-flight MCP loading to the background.</returns>
    public async Task<MoveMcpLoadingToBackgroundResult> MoveLoadingToBackgroundAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMcpMoveLoadingToBackgroundRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<MoveMcpLoadingToBackgroundResult>(_session.Rpc, "session.mcp.moveLoadingToBackground", [request], cancellationToken);
    }

    /// <summary>Reloads MCP server connections for the session with an explicit host-provided configuration.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>MCP server startup filtering result.</returns>
    internal async Task<McpStartServersResult> ReloadWithConfigAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new McpReloadWithConfigRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<McpStartServersResult>(_session.Rpc, "session.mcp.reloadWithConfig", [request], cancellationToken);
    }

    /// <summary>Runs an MCP sampling inference on behalf of an MCP server.</summary>
    /// <param name="requestId">Caller-provided unique identifier for this sampling execution. Use this same ID with cancelSamplingExecution to cancel the in-flight call. Must be unique within the session for the lifetime of the call.</param>
    /// <param name="serverName">Name of the MCP server that initiated the sampling request.</param>
    /// <param name="mcpRequestId">The original MCP JSON-RPC request ID (string or number). Used by the runtime to correlate the inference with the originating MCP request for telemetry; this is distinct from `requestId` (which is the schema-level cancellation handle).</param>
    /// <param name="request">Raw MCP CreateMessageRequest params, as received in the `sampling.requested` event. Treated as opaque at the schema layer; the runtime converts the embedded MCP messages into the OpenAI chat-completion shape internally.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Outcome of an MCP sampling execution: success result, failure error, or cancellation.</returns>
    public async Task<McpSamplingExecutionResult> ExecuteSamplingAsync(string requestId, string serverName, object mcpRequestId, McpExecuteSamplingRequest request, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(serverName);
        ArgumentNullException.ThrowIfNull(mcpRequestId);
        ArgumentNullException.ThrowIfNull(request);
        _session.ThrowIfDisposed();

        var rpcRequest = new McpExecuteSamplingParams { SessionId = _session.SessionId, RequestId = requestId, ServerName = serverName, McpRequestId = CopilotClient.ToJsonElementForWire(mcpRequestId)!.Value, Request = request };
        return await CopilotClient.InvokeRpcAsync<McpSamplingExecutionResult>(_session.Rpc, "session.mcp.executeSampling", [rpcRequest], cancellationToken);
    }

    /// <summary>Cancels an in-flight MCP sampling execution by request ID.</summary>
    /// <param name="requestId">The requestId previously passed to executeSampling that should be cancelled.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether an in-flight sampling execution with the given requestId was found and cancelled.</returns>
    public async Task<McpCancelSamplingExecutionResult> CancelSamplingExecutionAsync(string requestId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new McpCancelSamplingExecutionParams { SessionId = _session.SessionId, RequestId = requestId };
        return await CopilotClient.InvokeRpcAsync<McpCancelSamplingExecutionResult>(_session.Rpc, "session.mcp.cancelSamplingExecution", [request], cancellationToken);
    }

    /// <summary>Sets how environment-variable values supplied to MCP servers are resolved (direct or indirect).</summary>
    /// <param name="mode">How environment-variable values supplied to MCP servers are resolved. "direct" passes literal string values; "indirect" treats values as references (e.g. names of environment variables on the host) that the runtime resolves before launch. Defaults to the runtime's startup mode; clients that intentionally launch MCP servers with literal values (e.g. CLI prompt mode and ACP) set this to "direct".</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Env-value mode recorded on the session after the update.</returns>
    public async Task<McpSetEnvValueModeResult> SetEnvValueModeAsync(McpSetEnvValueModeDetails mode, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new McpSetEnvValueModeParams { SessionId = _session.SessionId, Mode = mode };
        return await CopilotClient.InvokeRpcAsync<McpSetEnvValueModeResult>(_session.Rpc, "session.mcp.setEnvValueMode", [request], cancellationToken);
    }

    /// <summary>Removes the auto-managed `github` MCP server when present.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).</returns>
    public async Task<McpRemoveGitHubResult> RemoveGitHubAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMcpRemoveGitHubRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<McpRemoveGitHubResult>(_session.Rpc, "session.mcp.removeGitHub", [request], cancellationToken);
    }

    /// <summary>Configures the built-in GitHub MCP server for the session's current auth context.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of configuring GitHub MCP.</returns>
    internal async Task<McpConfigureGitHubResult> ConfigureGitHubAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new McpConfigureGitHubRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<McpConfigureGitHubResult>(_session.Rpc, "session.mcp.configureGitHub", [request], cancellationToken);
    }

    /// <summary>Starts an individual MCP server on the live session. Omit `config` for a config-free start-by-name of an already-configured server (reuses the server's already-registered configuration); supply `config` to start from a caller-supplied configuration. Session-scoped and ephemeral: the server is added to this session's running set only and is reaped when the session ends. Does NOT modify persistent user configuration (`mcp.config.*`), so it does not affect future sessions. The server surfaces through `session.mcp.list` and the `session.mcp_servers_loaded` / `session.mcp_server_status_changed` events like any other server.</summary>
    /// <param name="serverName">Name of the MCP server to start.</param>
    /// <param name="config">MCP server configuration (stdio process or remote HTTP/SSE). Omit to start the server with its already-registered configuration (config-free start-by-name).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task StartServerAsync(string serverName, object? config = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpStartServerRequest { SessionId = _session.SessionId, ServerName = serverName, Config = CopilotClient.ToJsonElementForWire(config) };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.startServer", [request], cancellationToken);
    }

    /// <summary>Restarts an individual MCP server on the live session (stops then starts). Omit `config` for a config-free restart-by-name of an already-configured server; supply `config` to restart with a replacement configuration. Session-scoped and ephemeral: does NOT modify persistent user configuration (`mcp.config.*`).</summary>
    /// <param name="serverName">Name of the MCP server to restart.</param>
    /// <param name="config">Replacement MCP server configuration (stdio process or remote HTTP/SSE). Omit to restart the server with its already-registered configuration (config-free restart-by-name).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task RestartServerAsync(string serverName, object? config = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpRestartServerRequest { SessionId = _session.SessionId, ServerName = serverName, Config = CopilotClient.ToJsonElementForWire(config) };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.restartServer", [request], cancellationToken);
    }

    /// <summary>Stops an individual MCP server on the session's host.</summary>
    /// <param name="serverName">Name of the MCP server to stop.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task StopServerAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpStopServerRequest { SessionId = _session.SessionId, ServerName = serverName };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.stopServer", [request], cancellationToken);
    }

    /// <summary>Registers a pre-connected external MCP client (e.g. IDE) on the session's host. The caller retains lifecycle ownership of the client and transport. Marked internal because the `client` and `transport` arguments are in-process MCP SDK instances that cannot be serialized across the JSON-RPC boundary; once the CLI moves on top of the SDK, external clients will be expressed as transport configs the runtime can construct itself.</summary>
    /// <param name="serverName">Logical server name for the external client.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task RegisterExternalClientAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpRegisterExternalClientRequest { SessionId = _session.SessionId, ServerName = serverName };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.registerExternalClient", [request], cancellationToken);
    }

    /// <summary>Unregisters a previously registered external MCP client by server name. Marked internal as the paired companion of `registerExternalClient`: only in-process callers that registered a client this way can meaningfully unregister it. Disappears alongside `registerExternalClient`: once external clients are described to the runtime as config rather than handed in as instances, lifecycle (including deregistration) is owned entirely by the runtime.</summary>
    /// <param name="serverName">Server name of the external client to unregister.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task UnregisterExternalClientAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpUnregisterExternalClientRequest { SessionId = _session.SessionId, ServerName = serverName };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.unregisterExternalClient", [request], cancellationToken);
    }

    /// <summary>Checks whether a named MCP server is currently running on the session's host.</summary>
    /// <param name="serverName">Name of the MCP server to check.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the named MCP server is running.</returns>
    public async Task<McpIsServerRunningResult> IsServerRunningAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpIsServerRunningRequest { SessionId = _session.SessionId, ServerName = serverName };
        return await CopilotClient.InvokeRpcAsync<McpIsServerRunningResult>(_session.Rpc, "session.mcp.isServerRunning", [request], cancellationToken);
    }

    /// <summary>Oauth APIs.</summary>
    public McpOauthApi Oauth =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Headers APIs.</summary>
    public McpHeadersApi Headers =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Apps APIs.</summary>
    public McpAppsApi Apps =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Resources APIs.</summary>
    public McpResourcesApi Resources =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;
}

/// <summary>Provides session-scoped McpOauth APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpOauthApi
{
    private readonly CopilotSession _session;

    internal McpOauthApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Resolves a pending MCP OAuth request with a host-provided token or cancellation. The pending request is emitted as mcp.oauth_required with the data necessary to authorize the request.</summary>
    /// <param name="requestId">OAuth request identifier from the mcp.oauth_required event.</param>
    /// <param name="result">Host response to the pending OAuth request.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending MCP OAuth response was accepted.</returns>
    public async Task<McpOauthHandlePendingResult> HandlePendingRequestAsync(string requestId, McpOauthPendingRequestResponse result, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(result);
        _session.ThrowIfDisposed();

        var request = new McpOauthHandlePendingRequest { SessionId = _session.SessionId, RequestId = requestId, Result = result };
        return await CopilotClient.InvokeRpcAsync<McpOauthHandlePendingResult>(_session.Rpc, "session.mcp.oauth.handlePendingRequest", [request], cancellationToken);
    }

    /// <summary>Notifies the session that MCP OAuth authentication succeeded and updated credentials were persisted, so cached tool definitions can be refreshed.</summary>
    /// <param name="serverName">Name of the MCP server whose OAuth credentials were updated. Omit only when the host cannot identify the server.</param>
    /// <param name="refreshSessionToken">Whether the target session must mint a session-scoped access token instead of reusing a shared access token persisted by another session.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task AuthenticationStateChangedAsync(string? serverName = null, bool? refreshSessionToken = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new McpOauthAuthenticationStateChangedRequest { SessionId = _session.SessionId, ServerName = serverName, RefreshSessionToken = refreshSessionToken };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.oauth.authenticationStateChanged", [request], cancellationToken);
    }

    /// <summary>Starts OAuth authentication for a remote MCP server.</summary>
    /// <param name="serverName">Name of the remote MCP server to authenticate.</param>
    /// <param name="forceReauth">When true, clears any cached OAuth token for the server and runs a full new authorization. Use when the user explicitly wants to switch accounts or believes their session is stuck.</param>
    /// <param name="clientName">Optional override for the OAuth client display name shown on the consent screen. Applies to newly registered dynamic clients only — existing registrations keep the name they were created with. When omitted, the runtime applies a neutral fallback; callers driving interactive auth should pass their own surface-specific label so the consent screen matches the product the user sees.</param>
    /// <param name="callbackSuccessMessage">Optional override for the body text shown on the OAuth loopback callback success page. When omitted, the runtime applies a neutral fallback; callers driving interactive auth should pass surface-specific copy telling the user where to return.</param>
    /// <param name="clientId">Optional OAuth client ID override for this login. When set, the runtime uses this pre-registered static client instead of dynamic client registration.</param>
    /// <param name="clientSecret">Optional OAuth client secret override for this login. The runtime treats this as an ephemeral host-owned secret, uses it for this authentication attempt and does not persist it.</param>
    /// <param name="publicClient">Optional override indicating whether the static OAuth client is public. When false, the runtime treats it as confidential and uses the per-login clientSecret if provided, otherwise retrieving the client secret from the MCP OAuth secret store.</param>
    /// <param name="grantType">Optional OAuth grant type override for this login. Defaults to the server configuration, or authorization_code when no grant type is specified.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.</returns>
    public async Task<McpOauthLoginResult> LoginAsync(string serverName, bool? forceReauth = null, string? clientName = null, string? callbackSuccessMessage = null, string? clientId = null, string? clientSecret = null, bool? publicClient = null, McpOauthLoginGrantType? grantType = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpOauthLoginRequest { SessionId = _session.SessionId, ServerName = serverName, ForceReauth = forceReauth, ClientName = clientName, CallbackSuccessMessage = callbackSuccessMessage, ClientId = clientId, ClientSecret = clientSecret, PublicClient = publicClient, GrantType = grantType };
        return await CopilotClient.InvokeRpcAsync<McpOauthLoginResult>(_session.Rpc, "session.mcp.oauth.login", [request], cancellationToken);
    }

    /// <summary>Passively probes a configured remote MCP server to classify whether OAuth is required or a cached/override token is accepted. Does not start OAuth, emit pending OAuth requests, or mutate MCP connection state.</summary>
    /// <param name="serverName">Name of the configured remote MCP server to probe.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Passive MCP OAuth probe result. `authenticated` means the server accepted the probe request while an OAuth-origin access token was attached; it does not prove the server required or independently validated that token. The probe does not make a second unauthenticated request. Failed is an expected probe-domain outcome; JSON-RPC errors are reserved for API-call failures.</returns>
    public async Task<McpOauthProbeResult> ProbeAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpOauthProbeRequest { SessionId = _session.SessionId, ServerName = serverName };
        return await CopilotClient.InvokeRpcAsync<McpOauthProbeResult>(_session.Rpc, "session.mcp.oauth.probe", [request], cancellationToken);
    }

    /// <summary>Responds to a pending MCP OAuth authorization request by its request id.</summary>
    /// <param name="requestId">OAuth request identifier from the mcp.oauth_required event.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending MCP OAuth response was accepted.</returns>
    public async Task<McpOauthRespondResult> RespondAsync(string requestId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new McpOauthRespondRequest { SessionId = _session.SessionId, RequestId = requestId };
        return await CopilotClient.InvokeRpcAsync<McpOauthRespondResult>(_session.Rpc, "session.mcp.oauth.respond", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped McpHeaders APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpHeadersApi
{
    private readonly CopilotSession _session;

    internal McpHeadersApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Responds to a pending MCP dynamic headers refresh request. Hosts that subscribe to `mcp.headers_refresh_required` use this to provide short-lived per-server headers or to indicate that no dynamic headers are available for this refresh.</summary>
    /// <param name="requestId">Headers refresh request identifier from mcp.headers_refresh_required.</param>
    /// <param name="result">Host response: supply dynamic headers or decline this refresh.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending MCP headers refresh response was accepted.</returns>
    public async Task<McpHeadersHandlePendingHeadersRefreshRequestResult> HandlePendingHeadersRefreshRequestAsync(string requestId, McpHeadersHandlePendingHeadersRefreshRequest result, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(result);
        _session.ThrowIfDisposed();

        var request = new McpHeadersHandlePendingHeadersRefreshRequestRequest { SessionId = _session.SessionId, RequestId = requestId, Result = result };
        return await CopilotClient.InvokeRpcAsync<McpHeadersHandlePendingHeadersRefreshRequestResult>(_session.Rpc, "session.mcp.headers.handlePendingHeadersRefreshRequest", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped McpApps APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpAppsApi
{
    private readonly CopilotSession _session;

    internal McpAppsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Fetch an MCP resource (typically a `ui://` MCP App bundle, per SEP-1865) from a connected server. Requires the `mcp-apps` session capability.</summary>
    /// <param name="serverName">Name of the MCP server hosting the resource.</param>
    /// <param name="uri">Resource URI (typically ui://...).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Resource contents returned by the MCP server.</returns>
    public async Task<McpAppsReadResourceResult> ReadResourceAsync(string serverName, string uri, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        ArgumentNullException.ThrowIfNull(uri);
        _session.ThrowIfDisposed();

        var request = new McpAppsReadResourceRequest { SessionId = _session.SessionId, ServerName = serverName, Uri = uri };
        return await CopilotClient.InvokeRpcAsync<McpAppsReadResourceResult>(_session.Rpc, "session.mcp.apps.readResource", [request], cancellationToken);
    }

    /// <summary>List tools that an MCP App view is allowed to call (SEP-1865 visibility filter). Returns tools whose `_meta.ui.visibility` is unset (default `["model","app"]`) or includes `"app"`.</summary>
    /// <param name="serverName">MCP server hosting the app.</param>
    /// <param name="originServerName">**Required.** Server whose ui:// view issued the request. Per SEP-1865 ('callable by the app from this server only'), the call is rejected when this differs from `serverName`, and rejected outright when missing.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>App-callable tools from the named MCP server.</returns>
    public async Task<McpAppsListToolsResult> ListToolsAsync(string serverName, string originServerName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        ArgumentNullException.ThrowIfNull(originServerName);
        _session.ThrowIfDisposed();

        var request = new McpAppsListToolsRequest { SessionId = _session.SessionId, ServerName = serverName, OriginServerName = originServerName };
        return await CopilotClient.InvokeRpcAsync<McpAppsListToolsResult>(_session.Rpc, "session.mcp.apps.listTools", [request], cancellationToken);
    }

    /// <summary>Call an MCP tool from an MCP App view (SEP-1865). Enforces the visibility check that prevents an app iframe from invoking model-only tools. Returns the standard MCP `CallToolResult`.</summary>
    /// <param name="serverName">MCP server hosting the tool.</param>
    /// <param name="toolName">MCP tool name.</param>
    /// <param name="originServerName">**Required.** Server whose ui:// view issued the request. Per SEP-1865 ('callable by the app from this server only'), the call is rejected when this differs from `serverName`, and rejected outright when missing.</param>
    /// <param name="arguments">Tool arguments.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Standard MCP CallToolResult.</returns>
    public async Task<IDictionary<string, JsonElement>> CallToolAsync(string serverName, string toolName, string originServerName, IDictionary<string, JsonElement>? arguments = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        ArgumentNullException.ThrowIfNull(toolName);
        ArgumentNullException.ThrowIfNull(originServerName);
        _session.ThrowIfDisposed();

        var request = new McpAppsCallToolRequest { SessionId = _session.SessionId, ServerName = serverName, ToolName = toolName, OriginServerName = originServerName, Arguments = arguments };
        return await CopilotClient.InvokeRpcAsync<IDictionary<string, JsonElement>>(_session.Rpc, "session.mcp.apps.callTool", [request], cancellationToken);
    }

    /// <summary>Replace the host context returned to MCP App guests on `ui/initialize`. Hosts use this to advertise theme, locale, or other metadata to the guest UI.</summary>
    /// <param name="context">Host context advertised to MCP App guests.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetHostContextAsync(McpAppsSetHostContextDetails context, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(context);
        _session.ThrowIfDisposed();

        var request = new McpAppsSetHostContextRequest { SessionId = _session.SessionId, Context = context };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.mcp.apps.setHostContext", [request], cancellationToken);
    }

    /// <summary>Read the current host context advertised to MCP App guests.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current host context advertised to MCP App guests.</returns>
    public async Task<McpAppsHostContext> GetHostContextAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMcpAppsGetHostContextRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<McpAppsHostContext>(_session.Rpc, "session.mcp.apps.getHostContext", [request], cancellationToken);
    }

    /// <summary>Diagnose MCP Apps wiring for a specific MCP server. Reports the session capability, feature-flag state, advertised extension, and how many tools have `_meta.ui` populated.</summary>
    /// <param name="serverName">MCP server to probe.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Diagnostic snapshot of MCP Apps wiring for the named server.</returns>
    public async Task<McpAppsDiagnoseResult> DiagnoseAsync(string serverName, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpAppsDiagnoseRequest { SessionId = _session.SessionId, ServerName = serverName };
        return await CopilotClient.InvokeRpcAsync<McpAppsDiagnoseResult>(_session.Rpc, "session.mcp.apps.diagnose", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped McpResources APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class McpResourcesApi
{
    private readonly CopilotSession _session;

    internal McpResourcesApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Fetch an MCP resource from a connected server by URI (proxies MCP `resources/read`).</summary>
    /// <param name="serverName">Name of the MCP server hosting the resource.</param>
    /// <param name="uri">Resource URI.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Resource contents returned by the MCP server.</returns>
    public async Task<McpResourcesReadResult> ReadAsync(string serverName, string uri, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        ArgumentNullException.ThrowIfNull(uri);
        _session.ThrowIfDisposed();

        var request = new McpResourcesReadRequest { SessionId = _session.SessionId, ServerName = serverName, Uri = uri };
        return await CopilotClient.InvokeRpcAsync<McpResourcesReadResult>(_session.Rpc, "session.mcp.resources.read", [request], cancellationToken);
    }

    /// <summary>Enumerate one page of resources a connected MCP server exposes (proxies MCP `resources/list`). Pass `cursor` to continue from a prior result's `nextCursor`.</summary>
    /// <param name="serverName">Name of the MCP server whose resources to enumerate.</param>
    /// <param name="cursor">Opaque MCP pagination cursor from a prior `nextCursor` value.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>One page of resources advertised by the named MCP server.</returns>
    public async Task<McpResourcesListResult> ListAsync(string serverName, string? cursor = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpResourcesListRequest { SessionId = _session.SessionId, ServerName = serverName, Cursor = cursor };
        return await CopilotClient.InvokeRpcAsync<McpResourcesListResult>(_session.Rpc, "session.mcp.resources.list", [request], cancellationToken);
    }

    /// <summary>Enumerate one page of resource templates a connected MCP server exposes (proxies MCP `resources/templates/list`). Pass `cursor` to continue from a prior result's `nextCursor`.</summary>
    /// <param name="serverName">Name of the MCP server whose resource templates to enumerate.</param>
    /// <param name="cursor">Opaque MCP pagination cursor from a prior `nextCursor` value.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>One page of resource templates advertised by the named MCP server.</returns>
    public async Task<McpResourcesListTemplatesResult> ListTemplatesAsync(string serverName, string? cursor = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(serverName);
        _session.ThrowIfDisposed();

        var request = new McpResourcesListTemplatesRequest { SessionId = _session.SessionId, ServerName = serverName, Cursor = cursor };
        return await CopilotClient.InvokeRpcAsync<McpResourcesListTemplatesResult>(_session.Rpc, "session.mcp.resources.listTemplates", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Plugins APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PluginsApi
{
    private readonly CopilotSession _session;

    internal PluginsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists plugins installed for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Plugins installed for the session, with their enabled state and version metadata.</returns>
    public async Task<PluginList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionPluginsListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<PluginList>(_session.Rpc, "session.plugins.list", [request], cancellationToken);
    }

    /// <summary>Reloads the session's plugin set, refreshing MCP servers, custom agents, hooks, and skills cache so SDK-driven changes via `server.plugins.*` take effect immediately.</summary>
    /// <param name="request">Optional flags controlling which side effects the reload performs.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ReloadAsync(SessionPluginsReloadRequest? request = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var rpcRequest = new SessionPluginsReloadRequestWithSession { SessionId = _session.SessionId, ReloadMcp = request?.ReloadMcp, ReloadCustomAgents = request?.ReloadCustomAgents, ReloadHooks = request?.ReloadHooks, ReloadExtensions = request?.ReloadExtensions, DeferRepoHooks = request?.DeferRepoHooks };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.plugins.reload", [rpcRequest], cancellationToken);
    }
}

/// <summary>Provides session-scoped Provider APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ProviderApi
{
    private readonly CopilotSession _session;

    internal ProviderApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Returns the provider endpoint and credentials the session is currently configured to talk to, so the caller can make inference calls directly against the same backend the session uses.</summary>
    /// <param name="request">Optional model identifier to scope the endpoint snapshot to.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>A snapshot of the provider endpoint the session is currently configured to talk to.</returns>
    public async Task<ProviderEndpoint> GetEndpointAsync(SessionProviderGetEndpointRequest? request = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var rpcRequest = new SessionProviderGetEndpointRequestWithSession { SessionId = _session.SessionId, ModelId = request?.ModelId };
        return await CopilotClient.InvokeRpcAsync<ProviderEndpoint>(_session.Rpc, "session.provider.getEndpoint", [rpcRequest], cancellationToken);
    }

    /// <summary>Adds BYOK providers and/or models to the session's registry at runtime, extending the additive registry built from the session's `providers`/`models` options. Both fields are optional, so a call may add providers only, models only, or both. Within a single call providers are registered before models, so a model may reference a provider added in the same call; across calls a model may reference any provider already registered (from session creation or a prior add). A model whose referenced provider is not registered by the end of the call is rejected. Newly added models become selectable via `model.list` / `model.switchTo` and are inherited by sub-agents spawned afterwards.</summary>
    /// <param name="providers">Named BYOK provider connections to register, additive to any providers already in the registry. Each name must be unique across the registry and must not contain '/'.</param>
    /// <param name="models">BYOK model definitions to register. Each must reference a provider that is already registered or included in this same call. Selection ids (`provider/id`) must be unique across the registry.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The selectable model entries synthesized for the models added by this call.</returns>
    public async Task<ProviderAddResult> AddAsync(IList<NamedProviderConfig>? providers = null, IList<ProviderModelConfig>? models = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ProviderAddRequest { SessionId = _session.SessionId, Providers = providers, Models = models };
        return await CopilotClient.InvokeRpcAsync<ProviderAddResult>(_session.Rpc, "session.provider.add", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Options APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class OptionsApi
{
    private readonly CopilotSession _session;

    internal OptionsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Patches the genuinely-mutable subset of session options.</summary>
    /// <param name="model">The model ID to use for assistant turns.</param>
    /// <param name="modelCapabilitiesOverrides">Per-property model capability overrides for the selected model.</param>
    /// <param name="reasoningEffort">Reasoning effort for the selected model. CAPI values are model-defined and validated against the selected model; BYOK providers may define additional values. When omitted, no effort override is applied.</param>
    /// <param name="reasoningSummary">Reasoning summary mode for supported model clients.</param>
    /// <param name="verbosity">Output verbosity level for supported models.</param>
    /// <param name="clientName">Identifier of the client driving the session.</param>
    /// <param name="lspClientName">Identifier sent to LSP-style integrations.</param>
    /// <param name="integrationId">Stable integration identifier used for analytics and rate-limit attribution.</param>
    /// <param name="featureFlags">Map of feature-flag IDs to their boolean enabled state.</param>
    /// <param name="isExperimentalMode">Whether experimental capabilities are enabled.</param>
    /// <param name="provider">Custom model-provider configuration (BYOK).</param>
    /// <param name="capi">Options scoped to the built-in CAPI (Copilot API) provider.</param>
    /// <param name="workingDirectory">Absolute working-directory path for shell tools.</param>
    /// <param name="availableTools">Allowlist of tool names available to this session.</param>
    /// <param name="excludedTools">Denylist of tool names for this session.</param>
    /// <param name="includedBuiltinAgents">Built-in subagent names to include in this session. When specified, only these built-ins are available, subject to runtime availability and exclusions. Custom agents with the same name remain available. Set to null to remove the allowlist restriction.</param>
    /// <param name="excludedBuiltinAgents">Built-in subagent names to exclude from this session. Excluded built-ins are hidden from agent discovery and cannot be dispatched unless a custom agent with the same name is available.</param>
    /// <param name="toolFilterPrecedence">Controls how availableTools (allowlist) and excludedTools (denylist) combine when both are set.</param>
    /// <param name="enableScriptSafety">Whether shell-script safety heuristics are enabled.</param>
    /// <param name="shell">Per-session settings for built-in shell tools.</param>
    /// <param name="shellInitProfile">Use shell.initProfile instead. Shell init profile (`None` or `NonInteractive`).</param>
    /// <param name="shellProcessFlags">PowerShell process flags applied to built-in and user-requested shell commands.</param>
    /// <param name="sandboxConfig">Resolved sandbox configuration.</param>
    /// <param name="sandboxConfigSource">Origin of the sandbox choice. The runtime uses this only for internal telemetry provenance; managed policy is derived independently.</param>
    /// <param name="logInteractiveShells">Whether interactive shell sessions are logged.</param>
    /// <param name="envValueMode">How env values are passed to MCP servers (`direct` inlines literal values; `indirect` resolves at launch).</param>
    /// <param name="allowAllMcpServerInstructions">Whether to include instructions from every MCP server in the system prompt instead of only allowlisted servers.</param>
    /// <param name="skillDirectories">Additional directories to search for skills.</param>
    /// <param name="includedBuiltinSkills">Built-in skill names to include in this session. When specified, only these runtime-bundled skills are available. Skills from other sources with the same name remain available. Set to null to remove the allowlist restriction.</param>
    /// <param name="disabledSkills">Skill IDs that should be excluded from this session.</param>
    /// <param name="enableOnDemandInstructionDiscovery">Whether to discover custom instructions on demand after successful file views (AGENTS.md / CLAUDE.md / .github/copilot-instructions.md surfacing). Combined with `skipCustomInstructions`.</param>
    /// <param name="maxInlineBinaryBytes">Maximum decoded byte size of a single model-facing binary tool result (e.g. an image) persisted inline in session events and re-presented to the model on later turns / resume. Larger results are persisted as a metadata-only marker and shown to the model as a short text note. Defaults to 10 MB.</param>
    /// <param name="installedPlugins">Full set of installed plugins for the session. Replaces the existing list; the runtime invalidates the skills cache only when the list materially changes.</param>
    /// <param name="customAgentsLocalOnly">Whether to default custom agents to local-only execution.</param>
    /// <param name="suppressCustomAgentPrompt">When true, the selected custom agent's prompt is not injected into the user message (skill context is still injected). Used by automation triggers where the agent prompt is already in the problem statement.</param>
    /// <param name="skipCustomInstructions">Whether to skip loading custom instruction sources.</param>
    /// <param name="disabledInstructionSources">Instruction source IDs to exclude from the system prompt.</param>
    /// <param name="coauthorEnabled">Whether to include the `Co-authored-by` trailer in commit messages.</param>
    /// <param name="trajectoryFile">Optional path for trajectory output.</param>
    /// <param name="enableStreaming">Whether to stream model responses.</param>
    /// <param name="copilotUrl">Override URL for the Copilot API endpoint.</param>
    /// <param name="askUserDisabled">Whether to disable the `ask_user` tool (encourages autonomous behavior).</param>
    /// <param name="continueOnAutoMode">Whether to allow auto-mode continuation across turns.</param>
    /// <param name="runningInInteractiveMode">Whether the session is running in an interactive UI.</param>
    /// <param name="enableReasoningSummaries">Whether to surface reasoning-summary events from the model.</param>
    /// <param name="agentContext">Runtime context discriminator (e.g., `cli`, `actions`).</param>
    /// <param name="eventsLogDirectory">Override directory for the session-events log. When unset, the runtime's default events log directory is used.</param>
    /// <param name="eventsLogIncludesSubagents">Whether subagent callback events should be forwarded into the session event log sink.</param>
    /// <param name="additionalContentExclusionPolicies">Additional content-exclusion policies to merge into the session's policy set.</param>
    /// <param name="manageScheduleEnabled">Whether to expose the `manage_schedule` tool to the agent. The runtime always owns the per-session schedule registry; this flag only controls tool exposure (typically gated to staff users).</param>
    /// <param name="sessionCapabilities">Replaces the session's capability set with the given list. Use to enable or disable capabilities mid-session (e.g., remove `memory` for reproducible scripted runs). Omit the field to leave the existing capability set unchanged.</param>
    /// <param name="skipEmbeddingRetrieval">Whether to skip embedding retrieval pipeline initialization and execution.</param>
    /// <param name="organizationCustomInstructions">Organization-level custom instructions to inject into the system prompt.</param>
    /// <param name="enableFileHooks">Whether to enable loading of `.github/hooks/` filesystem hooks. Separate from the SDK callback hook mechanism.</param>
    /// <param name="enableHostGitOperations">Whether to enable host git operations (context resolution, child repo scanning, git info in system prompt).</param>
    /// <param name="enableSessionStore">Whether to enable cross-session store writes and reads.</param>
    /// <param name="enableSkills">Whether skill loading is enabled. Explicit false disables every source, including a bound SDK provider; changing the value invalidates the loaded skill snapshot. When omitted, creation falls back to enableConfigDiscovery unless an SDK skill provider is registered.</param>
    /// <param name="contextTier">Context tier for models with tiered pricing. The session uses this to derive effective `modelCapabilitiesOverrides` so compaction, truncation, token display, and request limits honor the selected tier.</param>
    /// <param name="sessionLimits">Optional session limits. Pass null to clear the session limits.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the session options patch was applied successfully.</returns>
    public async Task<SessionUpdateOptionsResult> UpdateAsync(string? model = null, ModelCapabilitiesOverride? modelCapabilitiesOverrides = null, string? reasoningEffort = null, OptionsUpdateReasoningSummary? reasoningSummary = null, Verbosity? verbosity = null, string? clientName = null, string? lspClientName = null, string? integrationId = null, IDictionary<string, bool>? featureFlags = null, bool? isExperimentalMode = null, ProviderConfig? provider = null, CapiSessionOptions? capi = null, string? workingDirectory = null, IList<string>? availableTools = null, IList<string>? excludedTools = null, IList<string>? includedBuiltinAgents = null, IList<string>? excludedBuiltinAgents = null, OptionsUpdateToolFilterPrecedence? toolFilterPrecedence = null, bool? enableScriptSafety = null, ShellOptions? shell = null, string? shellInitProfile = null, IList<string>? shellProcessFlags = null, SandboxConfig? sandboxConfig = null, SandboxConfigSource? sandboxConfigSource = null, bool? logInteractiveShells = null, OptionsUpdateEnvValueMode? envValueMode = null, bool? allowAllMcpServerInstructions = null, IList<string>? skillDirectories = null, IList<string>? includedBuiltinSkills = null, IList<string>? disabledSkills = null, bool? enableOnDemandInstructionDiscovery = null, long? maxInlineBinaryBytes = null, IList<SessionInstalledPlugin>? installedPlugins = null, bool? customAgentsLocalOnly = null, bool? suppressCustomAgentPrompt = null, bool? skipCustomInstructions = null, IList<string>? disabledInstructionSources = null, bool? coauthorEnabled = null, string? trajectoryFile = null, bool? enableStreaming = null, string? copilotUrl = null, bool? askUserDisabled = null, bool? continueOnAutoMode = null, bool? runningInInteractiveMode = null, bool? enableReasoningSummaries = null, string? agentContext = null, string? eventsLogDirectory = null, bool? eventsLogIncludesSubagents = null, IList<OptionsUpdateAdditionalContentExclusionPolicy>? additionalContentExclusionPolicies = null, bool? manageScheduleEnabled = null, IList<SessionCapability>? sessionCapabilities = null, bool? skipEmbeddingRetrieval = null, string? organizationCustomInstructions = null, bool? enableFileHooks = null, bool? enableHostGitOperations = null, bool? enableSessionStore = null, bool? enableSkills = null, OptionsUpdateContextTier? contextTier = null, SessionLimitsConfig? sessionLimits = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionUpdateOptionsParams { SessionId = _session.SessionId, Model = model, ModelCapabilitiesOverrides = modelCapabilitiesOverrides, ReasoningEffort = reasoningEffort, ReasoningSummary = reasoningSummary, Verbosity = verbosity, ClientName = clientName, LspClientName = lspClientName, IntegrationId = integrationId, FeatureFlags = featureFlags, IsExperimentalMode = isExperimentalMode, Provider = provider, Capi = capi, WorkingDirectory = workingDirectory, AvailableTools = availableTools, ExcludedTools = excludedTools, IncludedBuiltinAgents = includedBuiltinAgents, ExcludedBuiltinAgents = excludedBuiltinAgents, ToolFilterPrecedence = toolFilterPrecedence, EnableScriptSafety = enableScriptSafety, Shell = shell, ShellInitProfile = shellInitProfile, ShellProcessFlags = shellProcessFlags, SandboxConfig = sandboxConfig, SandboxConfigSource = sandboxConfigSource, LogInteractiveShells = logInteractiveShells, EnvValueMode = envValueMode, AllowAllMcpServerInstructions = allowAllMcpServerInstructions, SkillDirectories = skillDirectories, IncludedBuiltinSkills = includedBuiltinSkills, DisabledSkills = disabledSkills, EnableOnDemandInstructionDiscovery = enableOnDemandInstructionDiscovery, MaxInlineBinaryBytes = maxInlineBinaryBytes, InstalledPlugins = installedPlugins, CustomAgentsLocalOnly = customAgentsLocalOnly, SuppressCustomAgentPrompt = suppressCustomAgentPrompt, SkipCustomInstructions = skipCustomInstructions, DisabledInstructionSources = disabledInstructionSources, CoauthorEnabled = coauthorEnabled, TrajectoryFile = trajectoryFile, EnableStreaming = enableStreaming, CopilotUrl = copilotUrl, AskUserDisabled = askUserDisabled, ContinueOnAutoMode = continueOnAutoMode, RunningInInteractiveMode = runningInInteractiveMode, EnableReasoningSummaries = enableReasoningSummaries, AgentContext = agentContext, EventsLogDirectory = eventsLogDirectory, EventsLogIncludesSubagents = eventsLogIncludesSubagents, AdditionalContentExclusionPolicies = additionalContentExclusionPolicies, ManageScheduleEnabled = manageScheduleEnabled, SessionCapabilities = sessionCapabilities, SkipEmbeddingRetrieval = skipEmbeddingRetrieval, OrganizationCustomInstructions = organizationCustomInstructions, EnableFileHooks = enableFileHooks, EnableHostGitOperations = enableHostGitOperations, EnableSessionStore = enableSessionStore, EnableSkills = enableSkills, ContextTier = contextTier, SessionLimits = sessionLimits };
        return await CopilotClient.InvokeRpcAsync<SessionUpdateOptionsResult>(_session.Rpc, "session.options.update", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Lsp APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LspApi
{
    private readonly CopilotSession _session;

    internal LspApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Loads the merged LSP configuration set for the session's working directory.</summary>
    /// <param name="workingDirectory">Working directory used to load project-level LSP configs. Defaults to the session working directory when omitted.</param>
    /// <param name="gitRoot">Git root used as the boundary when traversing for project-level LSP configs (supports monorepos).</param>
    /// <param name="force">Force re-initialization even when LSP configs were already loaded for the working directory.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task InitializeAsync(string? workingDirectory = null, string? gitRoot = null, bool? force = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new LspInitializeRequest { SessionId = _session.SessionId, WorkingDirectory = workingDirectory, GitRoot = gitRoot, Force = force };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.lsp.initialize", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Extensions APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ExtensionsApi
{
    private readonly CopilotSession _session;

    internal ExtensionsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists extensions discovered for the session and their current status.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Extensions discovered for the session, with their current status.</returns>
    public async Task<ExtensionList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionExtensionsListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<ExtensionList>(_session.Rpc, "session.extensions.list", [request], cancellationToken);
    }

    /// <summary>Enables an extension for the session.</summary>
    /// <param name="id">Source-qualified extension ID to enable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task EnableAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new ExtensionsEnableRequest { SessionId = _session.SessionId, Id = id };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.extensions.enable", [request], cancellationToken);
    }

    /// <summary>Disables an extension for the session.</summary>
    /// <param name="id">Source-qualified extension ID to disable.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DisableAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new ExtensionsDisableRequest { SessionId = _session.SessionId, Id = id };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.extensions.disable", [request], cancellationToken);
    }

    /// <summary>Reloads extension definitions and processes for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ReloadAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionExtensionsReloadRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.extensions.reload", [request], cancellationToken);
    }

    /// <summary>Push attachments into the next user-message turn from an extension. The host should surface them as composer pills and forward them via the next session.send call. Callable only by extension-owned connections.</summary>
    /// <param name="attachments">Attachments to push into the next user-message turn. extension_context entries take the slim shape; standard variants take their full AttachmentSchema shape.</param>
    /// <param name="instanceId">Optional canvas instance binding the push for provenance. When supplied, the runtime resolves the canvas, verifies it is owned by the calling extension, and stamps canvasId/instanceId onto each extension_context entry. When omitted, no resolution runs and those fields stay unset on the attachment.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SendAttachmentsToMessageAsync(IList<PushAttachment> attachments, string? instanceId = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(attachments);
        _session.ThrowIfDisposed();

        var request = new SendAttachmentsToMessageParams { SessionId = _session.SessionId, Attachments = attachments, InstanceId = instanceId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.extensions.sendAttachmentsToMessage", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Tools APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ToolsApi
{
    private readonly CopilotSession _session;

    internal ToolsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Executes one tool from the session's currently offered tool set through the native invocation pipeline.</summary>
    /// <param name="name">Name of the currently offered tool to execute.</param>
    /// <param name="arguments">Arguments supplied to the tool.</param>
    /// <param name="toolCallId">Optional identifier used to correlate this invocation with its tool call.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Canonical result returned by a session tool.</returns>
    public async Task<JsonElement> ExecuteAsync(string name, object arguments, string? toolCallId = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        ArgumentNullException.ThrowIfNull(arguments);
        _session.ThrowIfDisposed();

        var request = new ToolsExecuteRequest { SessionId = _session.SessionId, Name = name, Arguments = CopilotClient.ToJsonElementForWire(arguments)!.Value, ToolCallId = toolCallId };
        return await CopilotClient.InvokeRpcAsync<JsonElement>(_session.Rpc, "session.tools.execute", [request], cancellationToken);
    }

    /// <summary>Returns the Rust-owned built-in tool descriptors used to construct the session's offered tool set.</summary>
    /// <param name="reduceUserIntervention">Whether descriptors should favor fewer user-intervention prompts.</param>
    /// <param name="includeAuthor">Whether tool descriptors should include authoring metadata.</param>
    /// <param name="skillEmbeddingEnabled">Whether semantic skill lookup is available.</param>
    /// <param name="shellConfig">Shell-specific names and description lines for shell tools.</param>
    /// <param name="shellSupportsPowerShell7Syntax">Whether the configured shell supports PowerShell 7 syntax.</param>
    /// <param name="shellTimeoutMs">Default shell timeout in milliseconds.</param>
    /// <param name="backgroundTaskNotificationsEnabled">Whether background task completion notifications are enabled.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Rust-owned built-in tool descriptors for the session.</returns>
    public async Task<ToolsGetBuiltinDescriptorsResult> GetBuiltinDescriptorsAsync(bool? reduceUserIntervention = null, bool? includeAuthor = null, bool? skillEmbeddingEnabled = null, ToolsShellDescriptorConfig? shellConfig = null, bool? shellSupportsPowerShell7Syntax = null, double? shellTimeoutMs = null, bool? backgroundTaskNotificationsEnabled = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ToolsGetBuiltinDescriptorsRequest { SessionId = _session.SessionId, ReduceUserIntervention = reduceUserIntervention, IncludeAuthor = includeAuthor, SkillEmbeddingEnabled = skillEmbeddingEnabled, ShellConfig = shellConfig, ShellSupportsPowerShell7Syntax = shellSupportsPowerShell7Syntax, ShellTimeoutMs = shellTimeoutMs, BackgroundTaskNotificationsEnabled = backgroundTaskNotificationsEnabled };
        return await CopilotClient.InvokeRpcAsync<ToolsGetBuiltinDescriptorsResult>(_session.Rpc, "session.tools.getBuiltinDescriptors", [request], cancellationToken);
    }

    /// <summary>Projects a completed task_complete tool call into its label-safe session event payload.</summary>
    /// <param name="toolArgs">Arguments supplied to the completed task_complete tool call.</param>
    /// <param name="finalResult">Final expanded result returned by the task_complete tool.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Task completion notification with summary from the agent.</returns>
    public async Task<TaskCompleteData> TaskCompleteEventDataAsync(object toolArgs, ToolResultExpanded finalResult, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(toolArgs);
        ArgumentNullException.ThrowIfNull(finalResult);
        _session.ThrowIfDisposed();

        var request = new ToolsTaskCompleteEventDataRequest { SessionId = _session.SessionId, ToolArgs = CopilotClient.ToJsonElementForWire(toolArgs)!.Value, FinalResult = finalResult };
        return await CopilotClient.InvokeRpcAsync<TaskCompleteData>(_session.Rpc, "session.tools.taskCompleteEventData", [request], cancellationToken);
    }

    /// <summary>Provides the result for a pending external tool call.</summary>
    /// <param name="requestId">Request ID of the pending tool call.</param>
    /// <param name="result">Tool call result (string or expanded result object).</param>
    /// <param name="error">Error message if the tool call failed.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the external tool call result was handled successfully.</returns>
    public async Task<HandlePendingToolCallResult> HandlePendingToolCallAsync(string requestId, object? result = null, string? error = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new HandlePendingToolCallRequest { SessionId = _session.SessionId, RequestId = requestId, Result = CopilotClient.ToJsonElementForWire(result), Error = error };
        return await CopilotClient.InvokeRpcAsync<HandlePendingToolCallResult>(_session.Rpc, "session.tools.handlePendingToolCall", [request], cancellationToken);
    }

    /// <summary>Resolves, builds, and validates the runtime tool list for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Resolve, build, and validate the runtime tool list for this session. Subagent sessions and consumer flows that need an initialized tool set before `send` invoke this. Default base-class implementation is a no-op for sessions that don't support tool validation.</returns>
    public async Task<ToolsInitializeAndValidateResult> InitializeAndValidateAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionToolsInitializeAndValidateRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<ToolsInitializeAndValidateResult>(_session.Rpc, "session.tools.initializeAndValidate", [request], cancellationToken);
    }

    /// <summary>Returns lightweight metadata for the session's currently initialized tools.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current lightweight tool metadata snapshot for the session.</returns>
    public async Task<ToolsGetCurrentMetadataResult> GetCurrentMetadataAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionToolsGetCurrentMetadataRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<ToolsGetCurrentMetadataResult>(_session.Rpc, "session.tools.getCurrentMetadata", [request], cancellationToken);
    }

    /// <summary>Atomically replaces the complete externally implemented tool list supplied by the calling connection. Built-in, MCP/plugin, extension-discovered, subagent, and tools supplied by other connections remain unchanged.</summary>
    /// <param name="tools">Complete replacement list for the calling connection.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Empty result after replacing the calling connection's externally implemented tools.</returns>
    public async Task<ToolsSetResult> SetAsync(IList<ProtocolExternalToolDefinition> tools, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(tools);
        _session.ThrowIfDisposed();

        var request = new ToolsSetRequest { SessionId = _session.SessionId, Tools = tools };
        return await CopilotClient.InvokeRpcAsync<ToolsSetResult>(_session.Rpc, "session.tools.set", [request], cancellationToken);
    }

    /// <summary>Sets the current session's live subagent settings override, which takes precedence over persisted user settings until cleared. Persisted user settings remain the source of truth for future sessions.</summary>
    /// <param name="subagents">Subagent settings to apply, or null to clear the live session override.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Empty result after applying subagent settings.</returns>
    public async Task<ToolsUpdateSubagentSettingsResult> UpdateSubagentSettingsAsync(UpdateSubagentSettingsRequestSubagents? subagents = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new UpdateSubagentSettingsRequest { SessionId = _session.SessionId, Subagents = subagents };
        return await CopilotClient.InvokeRpcAsync<ToolsUpdateSubagentSettingsResult>(_session.Rpc, "session.tools.updateSubagentSettings", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Commands APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class CommandsApi
{
    private readonly CopilotSession _session;

    internal CommandsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists slash commands available in the session.</summary>
    /// <param name="request">Optional filters controlling which command sources to include in the listing.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Slash commands available in the session, after applying any include/exclude filters.</returns>
    public async Task<CommandList> ListAsync(SessionCommandsListRequest? request = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var rpcRequest = new SessionCommandsListRequestWithSession { SessionId = _session.SessionId, IncludeBuiltins = request?.IncludeBuiltins, IncludeSkills = request?.IncludeSkills, IncludeClientCommands = request?.IncludeClientCommands };
        return await CopilotClient.InvokeRpcAsync<CommandList>(_session.Rpc, "session.commands.list", [rpcRequest], cancellationToken);
    }

    /// <summary>Invokes a slash command in the session.</summary>
    /// <param name="name">Command name. Leading slashes are stripped and the name is matched case-insensitively.</param>
    /// <param name="input">Raw input after the command name.</param>
    /// <param name="origin">Optional client surface that initiated the invocation.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of invoking the slash command (text output, prompt to send to the agent, completion, or subcommand selection).</returns>
    public async Task<SlashCommandInvocationResult> InvokeAsync(string name, string? input = null, CommandsInvocationOrigin? origin = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(name);
        _session.ThrowIfDisposed();

        var request = new CommandsInvokeRequest { SessionId = _session.SessionId, Name = name, Input = input, Origin = origin };
        return await CopilotClient.InvokeRpcAsync<SlashCommandInvocationResult>(_session.Rpc, "session.commands.invoke", [request], cancellationToken);
    }

    /// <summary>Finalizes persistence associated with a client-applied slash-command effect.</summary>
    /// <param name="effect">The slash-command result object that produced the pending effect, echoed back unchanged.</param>
    /// <param name="outcome">Whether the host applied or cancelled the pending invocation effect.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether finalizing the invocation effect succeeded, and the failure reason when it did not.</returns>
    internal async Task<CommandsFinalizeInvocationEffectResult> FinalizeInvocationEffectAsync(CommandsFinalizeInvocationEffectRequestEffect effect, CommandsInvocationEffectOutcome outcome, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(effect);
        _session.ThrowIfDisposed();

        var request = new CommandsFinalizeInvocationEffectRequest { SessionId = _session.SessionId, Effect = effect, Outcome = outcome };
        return await CopilotClient.InvokeRpcAsync<CommandsFinalizeInvocationEffectResult>(_session.Rpc, "session.commands.finalizeInvocationEffect", [request], cancellationToken);
    }

    /// <summary>Reports completion of a pending client-handled slash command.</summary>
    /// <param name="requestId">Request ID from the command invocation event.</param>
    /// <param name="error">Error message if the command handler failed.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending client-handled command was completed successfully.</returns>
    public async Task<CommandsHandlePendingCommandResult> HandlePendingCommandAsync(string requestId, string? error = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new CommandsHandlePendingCommandRequest { SessionId = _session.SessionId, RequestId = requestId, Error = error };
        return await CopilotClient.InvokeRpcAsync<CommandsHandlePendingCommandResult>(_session.Rpc, "session.commands.handlePendingCommand", [request], cancellationToken);
    }

    /// <summary>Executes a slash command synchronously and returns any error.</summary>
    /// <param name="commandName">Name of the slash command to invoke (without the leading '/').</param>
    /// <param name="args">Argument string to pass to the command (empty string if none).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Error message produced while executing the command, if any.</returns>
    public async Task<ExecuteCommandResult> ExecuteAsync(string commandName, string args, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(commandName);
        ArgumentNullException.ThrowIfNull(args);
        _session.ThrowIfDisposed();

        var request = new ExecuteCommandParams { SessionId = _session.SessionId, CommandName = commandName, Args = args };
        return await CopilotClient.InvokeRpcAsync<ExecuteCommandResult>(_session.Rpc, "session.commands.execute", [request], cancellationToken);
    }

    /// <summary>Enqueues a slash command for FIFO processing on the local session.</summary>
    /// <param name="command">Slash-prefixed command string to enqueue, e.g. '/compact' or '/model gpt-4'. Queued FIFO with any in-flight items; if the session is idle, processing kicks off immediately.</param>
    /// <param name="displayText">Optional user-facing text for the queue row. The command string is shown when omitted.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the command was accepted into the local execution queue.</returns>
    public async Task<EnqueueCommandResult> EnqueueAsync(string command, string? displayText = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(command);
        _session.ThrowIfDisposed();

        var request = new EnqueueCommandParams { SessionId = _session.SessionId, Command = command, DisplayText = displayText };
        return await CopilotClient.InvokeRpcAsync<EnqueueCommandResult>(_session.Rpc, "session.commands.enqueue", [request], cancellationToken);
    }

    /// <summary>Reports whether the host actually executed a queued command and whether to continue processing.</summary>
    /// <param name="requestId">Request ID from the `command.queued` event the host is responding to.</param>
    /// <param name="result">Result of the queued command execution.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the queued-command response was matched to a pending request.</returns>
    public async Task<CommandsRespondToQueuedCommandResult> RespondToQueuedCommandAsync(string requestId, QueuedCommandResult result, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(result);
        _session.ThrowIfDisposed();

        var request = new CommandsRespondToQueuedCommandRequest { SessionId = _session.SessionId, RequestId = requestId, Result = result };
        return await CopilotClient.InvokeRpcAsync<CommandsRespondToQueuedCommandResult>(_session.Rpc, "session.commands.respondToQueuedCommand", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Telemetry APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class TelemetryApi
{
    private readonly CopilotSession _session;

    internal TelemetryApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets the telemetry engagement ID currently associated with the session, when available.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Telemetry engagement ID for the session, when available.</returns>
    public async Task<SessionTelemetryEngagement> GetEngagementIdAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionTelemetryGetEngagementIdRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SessionTelemetryEngagement>(_session.Rpc, "session.telemetry.getEngagementId", [request], cancellationToken);
    }

    /// <summary>Sets feature override key/value pairs to attach to subsequent telemetry events for the session.</summary>
    /// <param name="features">Override key/value pairs to attach to subsequent telemetry events from this session. Replaces any previously-set overrides.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetFeatureOverridesAsync(IDictionary<string, string> features, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(features);
        _session.ThrowIfDisposed();

        var request = new TelemetrySetFeatureOverridesRequest { SessionId = _session.SessionId, Features = features };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.telemetry.setFeatureOverrides", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Ui APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UiApi
{
    private readonly CopilotSession _session;

    internal UiApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Runs a transient no-tools model query against the current conversation context.</summary>
    /// <param name="question">Question to answer from the current conversation context.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Completed transient query. Ordered chunks and the terminal outcome are also delivered through `ui.ephemeral_query` session events while it runs.</returns>
    public async Task<UIEphemeralQueryResult> EphemeralQueryAsync(string question, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(question);
        _session.ThrowIfDisposed();

        var request = new UIEphemeralQueryRequest { SessionId = _session.SessionId, Question = question };
        return await CopilotClient.InvokeRpcAsync<UIEphemeralQueryResult>(_session.Rpc, "session.ui.ephemeralQuery", [request], cancellationToken);
    }

    /// <summary>Requests structured input from a UI-capable client.</summary>
    /// <param name="message">Message describing what information is needed from the user.</param>
    /// <param name="requestedSchema">JSON Schema describing the form fields to present to the user.</param>
    /// <param name="mode">Elicitation mode. Omitted and form are equivalent for structured elicitation.</param>
    /// <param name="_meta">MCP request metadata.</param>
    /// <param name="task">MCP task metadata.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The elicitation response (accept with form values, decline, or cancel).</returns>
    public async Task<UIElicitationResponse> ElicitationAsync(string message, UIElicitationSchema requestedSchema, McpElicitationFormMode? mode = null, UIElicitationRequestMeta? _meta = null, McpTaskMetadata? task = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(message);
        ArgumentNullException.ThrowIfNull(requestedSchema);
        _session.ThrowIfDisposed();

        var request = new UIElicitationRequest { SessionId = _session.SessionId, Message = message, RequestedSchema = requestedSchema, Mode = mode, Meta = _meta, Task = task };
        return await CopilotClient.InvokeRpcAsync<UIElicitationResponse>(_session.Rpc, "session.ui.elicitation", [request], cancellationToken);
    }

    /// <summary>Provides the user response for a pending elicitation request.</summary>
    /// <param name="requestId">The unique request ID from the elicitation.requested event.</param>
    /// <param name="result">The elicitation response (accept with form values, decline, or cancel).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the elicitation response was accepted; false if it was already resolved by another client.</returns>
    public async Task<UIElicitationResult> HandlePendingElicitationAsync(string requestId, UIElicitationResponse result, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(result);
        _session.ThrowIfDisposed();

        var request = new UIHandlePendingElicitationRequest { SessionId = _session.SessionId, RequestId = requestId, Result = result };
        return await CopilotClient.InvokeRpcAsync<UIElicitationResult>(_session.Rpc, "session.ui.handlePendingElicitation", [request], cancellationToken);
    }

    /// <summary>Resolves a pending `user_input.requested` event with the user's response.</summary>
    /// <param name="requestId">The unique request ID from the user_input.requested event.</param>
    /// <param name="response">User response for a pending user-input request, with answer text and whether it was typed freeform.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending UI request was resolved by this call.</returns>
    public async Task<UIHandlePendingResult> HandlePendingUserInputAsync(string requestId, UIUserInputResponse response, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(response);
        _session.ThrowIfDisposed();

        var request = new UIHandlePendingUserInputRequest { SessionId = _session.SessionId, RequestId = requestId, Response = response };
        return await CopilotClient.InvokeRpcAsync<UIHandlePendingResult>(_session.Rpc, "session.ui.handlePendingUserInput", [request], cancellationToken);
    }

    /// <summary>Resolves a pending `sampling.requested` event with a sampling result, or rejects it.</summary>
    /// <param name="requestId">The unique request ID from the sampling.requested event.</param>
    /// <param name="response">Optional sampling result payload. Omit to reject/cancel the sampling request without providing a result.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending UI request was resolved by this call.</returns>
    public async Task<UIHandlePendingResult> HandlePendingSamplingAsync(string requestId, UIHandlePendingSamplingResponse? response = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new UIHandlePendingSamplingRequest { SessionId = _session.SessionId, RequestId = requestId, Response = response };
        return await CopilotClient.InvokeRpcAsync<UIHandlePendingResult>(_session.Rpc, "session.ui.handlePendingSampling", [request], cancellationToken);
    }

    /// <summary>Resolves a pending `auto_mode_switch.requested` event with the user's accept/decline decision.</summary>
    /// <param name="requestId">The unique request ID from the auto_mode_switch.requested event.</param>
    /// <param name="response">User's choice for auto-mode switching: yes (allow this turn), yes_always (allow + persist as setting), or no (decline).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending UI request was resolved by this call.</returns>
    public async Task<UIHandlePendingResult> HandlePendingAutoModeSwitchAsync(string requestId, UIAutoModeSwitchResponse response, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new UIHandlePendingAutoModeSwitchRequest { SessionId = _session.SessionId, RequestId = requestId, Response = response };
        return await CopilotClient.InvokeRpcAsync<UIHandlePendingResult>(_session.Rpc, "session.ui.handlePendingAutoModeSwitch", [request], cancellationToken);
    }

    /// <summary>Resolves a pending `session_limits_exhausted.requested` event with the user's selected limit action.</summary>
    /// <param name="requestId">The unique request ID from the session_limits_exhausted.requested event.</param>
    /// <param name="response">The selected session-limit action.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending UI request was resolved by this call.</returns>
    public async Task<UIHandlePendingResult> HandlePendingSessionLimitsExhaustedAsync(string requestId, UISessionLimitsExhaustedResponse response, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(response);
        _session.ThrowIfDisposed();

        var request = new UIHandlePendingSessionLimitsExhaustedRequest { SessionId = _session.SessionId, RequestId = requestId, Response = response };
        return await CopilotClient.InvokeRpcAsync<UIHandlePendingResult>(_session.Rpc, "session.ui.handlePendingSessionLimitsExhausted", [request], cancellationToken);
    }

    /// <summary>Resolves a pending `exit_plan_mode.requested` event with the user's response.</summary>
    /// <param name="requestId">The unique request ID from the exit_plan_mode.requested event.</param>
    /// <param name="response">User response for a pending exit-plan-mode request, with approval state, selected action, auto-approve flag, and feedback.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the pending UI request was resolved by this call.</returns>
    public async Task<UIHandlePendingResult> HandlePendingExitPlanModeAsync(string requestId, UIExitPlanModeResponse response, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(response);
        _session.ThrowIfDisposed();

        var request = new UIHandlePendingExitPlanModeRequest { SessionId = _session.SessionId, RequestId = requestId, Response = response };
        return await CopilotClient.InvokeRpcAsync<UIHandlePendingResult>(_session.Rpc, "session.ui.handlePendingExitPlanMode", [request], cancellationToken);
    }

    /// <summary>Registers an in-process handler for auto-mode-switch requests so the server bridge skips dispatch.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Register an in-process handler for `auto_mode_switch.requested` events. The caller still attaches the actual listener via the standard event-subscription mechanism; this registration solely tells the server bridge to skip its own dispatch (so a remote client doesn't race the in-process handler for the same requestId).</returns>
    public async Task<UIRegisterDirectAutoModeSwitchHandlerResult> RegisterDirectAutoModeSwitchHandlerAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionUiRegisterDirectAutoModeSwitchHandlerRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<UIRegisterDirectAutoModeSwitchHandlerResult>(_session.Rpc, "session.ui.registerDirectAutoModeSwitchHandler", [request], cancellationToken);
    }

    /// <summary>Unregisters a previously-registered in-process auto-mode-switch handler by its opaque handle.</summary>
    /// <param name="handle">Handle previously returned by `registerDirectAutoModeSwitchHandler`.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the handle was active and the registration count was decremented.</returns>
    public async Task<UIUnregisterDirectAutoModeSwitchHandlerResult> UnregisterDirectAutoModeSwitchHandlerAsync(string handle, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(handle);
        _session.ThrowIfDisposed();

        var request = new UIUnregisterDirectAutoModeSwitchHandlerRequest { SessionId = _session.SessionId, Handle = handle };
        return await CopilotClient.InvokeRpcAsync<UIUnregisterDirectAutoModeSwitchHandlerResult>(_session.Rpc, "session.ui.unregisterDirectAutoModeSwitchHandler", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Permissions APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsApi
{
    private readonly CopilotSession _session;

    internal PermissionsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Replaces selected permission policy fields (rules, paths, URLs, exclusions, allow-all flags) on the session.</summary>
    /// <param name="approveAllToolPermissionRequests">If specified, sets whether tool permission requests are auto-approved without prompting. Omit to leave the current value unchanged.</param>
    /// <param name="approveAllReadPermissionRequests">If specified, sets whether path/URL read permission requests are auto-approved. Omit to leave the current value unchanged.</param>
    /// <param name="rules">If specified, replaces the session's approved/denied permission rules. Omit to leave the current rules unchanged.</param>
    /// <param name="paths">If specified, replaces the session's path-permission policy. The runtime constructs the appropriate PathManager based on these inputs (rooted at the session's working directory). Omit to leave the current path policy unchanged.</param>
    /// <param name="urls">If specified, replaces the session's URL-permission policy. The runtime constructs a fresh DefaultUrlManager based on these inputs. Omit to leave the current URL policy unchanged.</param>
    /// <param name="additionalContentExclusionPolicies">If specified, replaces the host-supplied GitHub Content Exclusion policies on the session (combined with natively-discovered policies when evaluating tool/file access). Omit to leave the current policies unchanged.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsConfigureResult> ConfigureAsync(bool? approveAllToolPermissionRequests = null, bool? approveAllReadPermissionRequests = null, PermissionRulesSet? rules = null, PermissionPathsConfig? paths = null, PermissionUrlsConfig? urls = null, IList<PermissionsConfigureAdditionalContentExclusionPolicy>? additionalContentExclusionPolicies = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsConfigureParams { SessionId = _session.SessionId, ApproveAllToolPermissionRequests = approveAllToolPermissionRequests, ApproveAllReadPermissionRequests = approveAllReadPermissionRequests, Rules = rules, Paths = paths, Urls = urls, AdditionalContentExclusionPolicies = additionalContentExclusionPolicies };
        return await CopilotClient.InvokeRpcAsync<PermissionsConfigureResult>(_session.Rpc, "session.permissions.configure", [request], cancellationToken);
    }

    /// <summary>Provides a decision for a pending tool permission request.</summary>
    /// <param name="requestId">Request ID of the pending permission request.</param>
    /// <param name="result">The client's response to the pending permission prompt.</param>
    /// <param name="decisionContext">Optional informational context describing how and where this response was made. Omit it to preserve legacy behavior without attributing an origin.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the permission decision was applied; false when the request was already resolved.</returns>
    public async Task<PermissionRequestResult> HandlePendingPermissionRequestAsync(string requestId, PermissionDecision result, PermissionDecisionContext? decisionContext = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(result);
        _session.ThrowIfDisposed();

        var request = new PermissionDecisionRequest { SessionId = _session.SessionId, RequestId = requestId, Result = result, DecisionContext = decisionContext };
        return await CopilotClient.InvokeRpcAsync<PermissionRequestResult>(_session.Rpc, "session.permissions.handlePendingPermissionRequest", [request], cancellationToken);
    }

    /// <summary>Reconstructs the set of pending tool permission requests from the session's event history.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>List of pending permission requests reconstructed from event history.</returns>
    public async Task<PendingPermissionRequestList> PendingRequestsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsPendingRequestsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<PendingPermissionRequestList>(_session.Rpc, "session.permissions.pendingRequests", [request], cancellationToken);
    }

    /// <summary>Enables or disables automatic approval of tool permission requests for the session.</summary>
    /// <param name="enabled">Whether to auto-approve all tool permission requests.</param>
    /// <param name="source">Optional source for allow-all telemetry. Defaults to `rpc` when omitted for SDK callers.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsSetApproveAllResult> SetApproveAllAsync(bool enabled, PermissionsSetApproveAllSource? source = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsSetApproveAllRequest { SessionId = _session.SessionId, Enabled = enabled, Source = source };
        return await CopilotClient.InvokeRpcAsync<PermissionsSetApproveAllResult>(_session.Rpc, "session.permissions.setApproveAll", [request], cancellationToken);
    }

    /// <summary>Sets the permission mode for the session. `manual` follows the normal approval flow, `assisted` attaches LLM safety recommendations, and `allow-all` automatically approves permission requests. The result returns the authoritative post-mutation mode so callers can update local state without racing the `session.permissions_changed` notification.</summary>
    /// <param name="mode">Permission mode to apply.</param>
    /// <param name="assistedApprovalModel">Optional judge model id for assisted mode. When omitted, the session resolves the provider default: `gpt-5.5` for CAPI sessions and the active session model for BYOK sessions.</param>
    /// <param name="source">Optional source for permission-mode telemetry. Defaults to `rpc` when omitted for SDK callers.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the requested permission mode was applied and reports the authoritative post-mutation mode.</returns>
    public async Task<PermissionsSetModeResult> SetModeAsync(PermissionMode mode, string? assistedApprovalModel = null, PermissionModeSource? source = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsSetModeRequest { SessionId = _session.SessionId, Mode = mode, AssistedApprovalModel = assistedApprovalModel, Source = source };
        return await CopilotClient.InvokeRpcAsync<PermissionsSetModeResult>(_session.Rpc, "session.permissions.setMode", [request], cancellationToken);
    }

    /// <summary>Returns the current permission mode for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current permission mode.</returns>
    public async Task<PermissionsGetModeResult> GetModeAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsGetModeRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<PermissionsGetModeResult>(_session.Rpc, "session.permissions.getMode", [request], cancellationToken);
    }

    /// <summary>Adds or removes session-scoped or location-scoped permission rules.</summary>
    /// <param name="scope">Whether the change applies to ephemeral session-scoped rules (cleared at session end) or to location-scoped rules persisted via the location-permissions config file.</param>
    /// <param name="add">Rules to add to the scope. Applied before `remove`/`removeAll`.</param>
    /// <param name="remove">Specific rules to remove from the scope. Ignored when `removeAll` is true.</param>
    /// <param name="removeAll">When true, removes every rule currently in the scope (after any `add` is applied). Useful for clearing the location scope wholesale.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsModifyRulesResult> ModifyRulesAsync(PermissionsModifyRulesScope scope, IList<PermissionRule>? add = null, IList<PermissionRule>? remove = null, bool? removeAll = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsModifyRulesParams { SessionId = _session.SessionId, Scope = scope, Add = add, Remove = remove, RemoveAll = removeAll };
        return await CopilotClient.InvokeRpcAsync<PermissionsModifyRulesResult>(_session.Rpc, "session.permissions.modifyRules", [request], cancellationToken);
    }

    /// <summary>Sets whether the client wants permission prompts bridged into session events.</summary>
    /// <param name="required">Whether the client wants `permission.requested` events bridged from the session-owned permission service. CLI clients that render prompt UI set this to `true` for as long as their listener is mounted; headless callers leave it unset (the default is `false`).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsSetRequiredResult> SetRequiredAsync(bool required, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsSetRequiredRequest { SessionId = _session.SessionId, Required = required };
        return await CopilotClient.InvokeRpcAsync<PermissionsSetRequiredResult>(_session.Rpc, "session.permissions.setRequired", [request], cancellationToken);
    }

    /// <summary>Clears session-scoped tool permission approvals.</summary>
    /// <param name="includeLocation">Whether location-scoped approvals are cleared too. Defaults to `true`.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsResetSessionApprovalsResult> ResetSessionApprovalsAsync(bool? includeLocation = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsResetSessionApprovalsRequest { SessionId = _session.SessionId, IncludeLocation = includeLocation };
        return await CopilotClient.InvokeRpcAsync<PermissionsResetSessionApprovalsResult>(_session.Rpc, "session.permissions.resetSessionApprovals", [request], cancellationToken);
    }

    /// <summary>Notifies the runtime that a permission prompt UI has been shown to the user.</summary>
    /// <param name="message">Human-readable description of the prompt the user is being asked to approve. Used by the runtime to fire the registered `permission_prompt` notification hook (e.g. terminal bell, desktop notification).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsNotifyPromptShownResult> NotifyPromptShownAsync(string message, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(message);
        _session.ThrowIfDisposed();

        var request = new PermissionPromptShownNotification { SessionId = _session.SessionId, Message = message };
        return await CopilotClient.InvokeRpcAsync<PermissionsNotifyPromptShownResult>(_session.Rpc, "session.permissions.notifyPromptShown", [request], cancellationToken);
    }

    /// <summary>Paths APIs.</summary>
    public PermissionsPathsApi Paths =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Locations APIs.</summary>
    public PermissionsLocationsApi Locations =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>FolderTrust APIs.</summary>
    public PermissionsFolderTrustApi FolderTrust =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;

    /// <summary>Urls APIs.</summary>
    public PermissionsUrlsApi Urls =>
        field ??
        Interlocked.CompareExchange(ref field, new(_session), null) ??
        field;
}

/// <summary>Provides session-scoped PermissionsPaths APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsPathsApi
{
    private readonly CopilotSession _session;

    internal PermissionsPathsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Returns the session's allowed directories and primary working directory.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Snapshot of the session's allow-listed directories and primary working directory.</returns>
    public async Task<PermissionPathsList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionsPathsListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<PermissionPathsList>(_session.Rpc, "session.permissions.paths.list", [request], cancellationToken);
    }

    /// <summary>Adds a directory to the session's allow-list and activates conventional skill and agent definitions under it.</summary>
    /// <param name="path">Directory to add to the allow-list. The runtime resolves and validates the path before adding, then loads conventional `.github/skills/` and `.github/agents/` definitions under it when their subsystem gates are enabled. Adding the directory is therefore also a trust decision for configuration stored there.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsPathsAddResult> AddAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        _session.ThrowIfDisposed();

        var request = new PermissionPathsAddParams { SessionId = _session.SessionId, Path = path };
        return await CopilotClient.InvokeRpcAsync<PermissionsPathsAddResult>(_session.Rpc, "session.permissions.paths.add", [request], cancellationToken);
    }

    /// <summary>Updates the session's primary working directory used by the permission policy.</summary>
    /// <param name="path">Directory to set as the new primary working directory for the session's permission policy.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsPathsUpdatePrimaryResult> UpdatePrimaryAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        _session.ThrowIfDisposed();

        var request = new PermissionPathsUpdatePrimaryParams { SessionId = _session.SessionId, Path = path };
        return await CopilotClient.InvokeRpcAsync<PermissionsPathsUpdatePrimaryResult>(_session.Rpc, "session.permissions.paths.updatePrimary", [request], cancellationToken);
    }

    /// <summary>Reports whether a path falls within any of the session's allowed directories.</summary>
    /// <param name="path">Path to check against the session's allowed directories.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the supplied path is within the session's allowed directories.</returns>
    public async Task<PermissionPathsAllowedCheckResult> IsPathWithinAllowedDirectoriesAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        _session.ThrowIfDisposed();

        var request = new PermissionPathsAllowedCheckParams { SessionId = _session.SessionId, Path = path };
        return await CopilotClient.InvokeRpcAsync<PermissionPathsAllowedCheckResult>(_session.Rpc, "session.permissions.paths.isPathWithinAllowedDirectories", [request], cancellationToken);
    }

    /// <summary>Reports whether a path falls within the session's workspace (primary) directory.</summary>
    /// <param name="path">Path to check against the session workspace directory.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the supplied path is within the session's workspace directory.</returns>
    public async Task<PermissionPathsWorkspaceCheckResult> IsPathWithinWorkspaceAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        _session.ThrowIfDisposed();

        var request = new PermissionPathsWorkspaceCheckParams { SessionId = _session.SessionId, Path = path };
        return await CopilotClient.InvokeRpcAsync<PermissionPathsWorkspaceCheckResult>(_session.Rpc, "session.permissions.paths.isPathWithinWorkspace", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped PermissionsLocations APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsLocationsApi
{
    private readonly CopilotSession _session;

    internal PermissionsLocationsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Resolves the permission location key and type for a working directory.</summary>
    /// <param name="workingDirectory">Working directory whose permission location should be resolved.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Resolved location-permissions key and type.</returns>
    public async Task<PermissionLocationResolveResult> ResolveAsync(string workingDirectory, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(workingDirectory);
        _session.ThrowIfDisposed();

        var request = new PermissionLocationResolveParams { SessionId = _session.SessionId, WorkingDirectory = workingDirectory };
        return await CopilotClient.InvokeRpcAsync<PermissionLocationResolveResult>(_session.Rpc, "session.permissions.locations.resolve", [request], cancellationToken);
    }

    /// <summary>Applies persisted location-scoped tool approvals and allowed directories for a working directory to this session's permission service.</summary>
    /// <param name="workingDirectory">Working directory whose persisted location permissions should be applied.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Summary of persisted location permissions applied to the session.</returns>
    public async Task<PermissionLocationApplyResult> ApplyAsync(string workingDirectory, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(workingDirectory);
        _session.ThrowIfDisposed();

        var request = new PermissionLocationApplyParams { SessionId = _session.SessionId, WorkingDirectory = workingDirectory };
        return await CopilotClient.InvokeRpcAsync<PermissionLocationApplyResult>(_session.Rpc, "session.permissions.locations.apply", [request], cancellationToken);
    }

    /// <summary>Persists a tool approval for a permission location and applies its rules to this session's live permission service.</summary>
    /// <param name="locationKey">Location key (git root or cwd) to persist the approval to.</param>
    /// <param name="approval">Tool approval to persist and apply.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsLocationsAddToolApprovalResult> AddToolApprovalAsync(string locationKey, PermissionsLocationsAddToolApprovalDetails approval, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(locationKey);
        ArgumentNullException.ThrowIfNull(approval);
        _session.ThrowIfDisposed();

        var request = new PermissionLocationAddToolApprovalParams { SessionId = _session.SessionId, LocationKey = locationKey, Approval = approval };
        return await CopilotClient.InvokeRpcAsync<PermissionsLocationsAddToolApprovalResult>(_session.Rpc, "session.permissions.locations.addToolApproval", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped PermissionsFolderTrust APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsFolderTrustApi
{
    private readonly CopilotSession _session;

    internal PermissionsFolderTrustApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Reports whether a folder is trusted according to the user's folder trust state.</summary>
    /// <param name="path">Folder path to check.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Folder trust check result.</returns>
    public async Task<FolderTrustCheckResult> IsTrustedAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        _session.ThrowIfDisposed();

        var request = new FolderTrustCheckParams { SessionId = _session.SessionId, Path = path };
        return await CopilotClient.InvokeRpcAsync<FolderTrustCheckResult>(_session.Rpc, "session.permissions.folderTrust.isTrusted", [request], cancellationToken);
    }

    /// <summary>Adds a folder to the user's trusted folders list.</summary>
    /// <param name="path">Folder path to mark as trusted.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsFolderTrustAddTrustedResult> AddTrustedAsync(string path, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(path);
        _session.ThrowIfDisposed();

        var request = new FolderTrustAddParams { SessionId = _session.SessionId, Path = path };
        return await CopilotClient.InvokeRpcAsync<PermissionsFolderTrustAddTrustedResult>(_session.Rpc, "session.permissions.folderTrust.addTrusted", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped PermissionsUrls APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class PermissionsUrlsApi
{
    private readonly CopilotSession _session;

    internal PermissionsUrlsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Toggles the runtime's URL-permission policy between unrestricted and restricted modes.</summary>
    /// <param name="enabled">Whether to allow access to all URLs without prompting. Toggles the runtime's URL-permission policy in place.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<PermissionsUrlsSetUnrestrictedModeResult> SetUnrestrictedModeAsync(bool enabled, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new PermissionUrlsSetUnrestrictedModeParams { SessionId = _session.SessionId, Enabled = enabled };
        return await CopilotClient.InvokeRpcAsync<PermissionsUrlsSetUnrestrictedModeResult>(_session.Rpc, "session.permissions.urls.setUnrestrictedMode", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Metadata APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class MetadataApi
{
    private readonly CopilotSession _session;

    internal MetadataApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Returns a snapshot of the session's identifying metadata, mode, agent, and remote info.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Point-in-time snapshot of slow-changing session identifier and state fields.</returns>
    public async Task<SessionMetadataSnapshot> SnapshotAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMetadataSnapshotRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SessionMetadataSnapshot>(_session.Rpc, "session.metadata.snapshot", [request], cancellationToken);
    }

    /// <summary>Returns the client-owned string metadata persisted with this local session. The metadata is not included in model context, events, telemetry, snapshots, or remote exports.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.</returns>
    public async Task<IDictionary<string, string>> GetClientMetadataAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMetadataGetClientMetadataRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<IDictionary<string, string>>(_session.Rpc, "session.metadata.getClientMetadata", [request], cancellationToken);
    }

    /// <summary>Atomically patches the client-owned string metadata persisted with this local session and returns the committed bag.</summary>
    /// <param name="clear">Remove every existing client metadata entry before applying remove and set. Defaults to false.</param>
    /// <param name="remove">Case-sensitive keys to remove. Missing keys are ignored. Each key must be non-empty, at most 256 UTF-8 bytes, and outside the reserved `copilot/` and `github/` namespaces.</param>
    /// <param name="set">String entries to add or replace. Set wins when a key also appears in remove. Each key must be non-empty, at most 256 UTF-8 bytes, and outside the reserved `copilot/` and `github/` namespaces. Each value may contain at most 16 KiB of UTF-8 data.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.</returns>
    public async Task<IDictionary<string, string>> UpdateClientMetadataAsync(bool? clear = null, IList<string>? remove = null, IDictionary<string, string>? set = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new MetadataUpdateClientMetadataRequest { SessionId = _session.SessionId, Clear = clear, Remove = remove, Set = set };
        return await CopilotClient.InvokeRpcAsync<IDictionary<string, string>>(_session.Rpc, "session.metadata.updateClientMetadata", [request], cancellationToken);
    }

    /// <summary>Reports whether the local session is currently processing user/agent messages.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the local session is currently processing a turn or background continuation.</returns>
    public async Task<MetadataIsProcessingResult> IsProcessingAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMetadataIsProcessingRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<MetadataIsProcessingResult>(_session.Rpc, "session.metadata.isProcessing", [request], cancellationToken);
    }

    /// <summary>Returns a snapshot of activity flags for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current activity flags for the session.</returns>
    public async Task<SessionActivity> ActivityAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMetadataActivityRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SessionActivity>(_session.Rpc, "session.metadata.activity", [request], cancellationToken);
    }

    /// <summary>Returns the token breakdown for the session's current context window for a given model.</summary>
    /// <param name="promptTokenLimit">Maximum prompt tokens allowed by the target model. Pass 0 to use the runtime default.</param>
    /// <param name="outputTokenLimit">Maximum output tokens allowed by the target model. Pass 0 if unknown.</param>
    /// <param name="selectedModel">Model identifier used for tokenization. Omit to use the session default. Used both for token counting and to compute display values.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Token breakdown for the session's current context window, or null if uninitialized.</returns>
    public async Task<MetadataContextInfoResult> ContextInfoAsync(long promptTokenLimit, long outputTokenLimit, string? selectedModel = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new MetadataContextInfoRequest { SessionId = _session.SessionId, PromptTokenLimit = promptTokenLimit, OutputTokenLimit = outputTokenLimit, SelectedModel = selectedModel };
        return await CopilotClient.InvokeRpcAsync<MetadataContextInfoResult>(_session.Rpc, "session.metadata.contextInfo", [request], cancellationToken);
    }

    /// <summary>Returns the experimental per-source attribution breakdown of the session's current context window as a flat list of entries (skills, subagents, MCP servers, built-in tools, plugin rollups, system/tool-definition costs, with nesting via parentId), plus the successful compaction count. The heaviest individual messages are available separately via `metadata.getContextHeaviestMessages`. Returns null until the session has initialized its system prompt and tool metadata.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Per-source attribution breakdown for the session's current context window, or null if uninitialized.</returns>
    public async Task<MetadataContextAttributionResult> GetContextAttributionAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionMetadataGetContextAttributionRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<MetadataContextAttributionResult>(_session.Rpc, "session.metadata.getContextAttribution", [request], cancellationToken);
    }

    /// <summary>Returns the largest individual messages currently in the session's context window, most-expensive first. Companion to `metadata.getContextAttribution`. Returns an empty list until the session has initialized.</summary>
    /// <param name="limit">Maximum number of messages to return, most-expensive first. Omit for the server default.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The heaviest individual messages in the session's context window, most-expensive first.</returns>
    public async Task<MetadataContextHeaviestMessagesResult> GetContextHeaviestMessagesAsync(long? limit = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new MetadataContextHeaviestMessagesRequest { SessionId = _session.SessionId, Limit = limit };
        return await CopilotClient.InvokeRpcAsync<MetadataContextHeaviestMessagesResult>(_session.Rpc, "session.metadata.getContextHeaviestMessages", [request], cancellationToken);
    }

    /// <summary>Records a working-directory/git context change and emits a `session.context_changed` event. For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event): a local session's working directory is authoritative and is moved via `metadata.setWorkingDirectory` (or an SDK `session.resume` that supplies a `workingDirectory`), not by this method.</summary>
    /// <param name="context">Updated working directory and git context. Emitted as the new payload of `session.context_changed`.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Notify the session that its working directory context has changed. Emits a `session.context_changed` event so consumers (telemetry, OTel tracker, ACP, the timeline UI) can react. Use this when the host has detected a cwd/branch/repo change outside the session's normal lifecycle (e.g., after a shell command in interactive mode). For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event); move a local session's working directory via `metadata.setWorkingDirectory` instead.</returns>
    public async Task<MetadataRecordContextChangeResult> RecordContextChangeAsync(SessionWorkingDirectoryContext context, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(context);
        _session.ThrowIfDisposed();

        var request = new MetadataRecordContextChangeRequest { SessionId = _session.SessionId, Context = context };
        return await CopilotClient.InvokeRpcAsync<MetadataRecordContextChangeResult>(_session.Rpc, "session.metadata.recordContextChange", [request], cancellationToken);
    }

    /// <summary>Updates the session's working directory. For local sessions the target is validated first (an absolute path that exists on disk) and the permission primary directory is re-based; a rejected validation fails the call before any session state changes.</summary>
    /// <param name="workingDirectory">Absolute path to set as the session's working directory. The runtime updates the session's recorded cwd so subsequent operations (shell tools, file lookups, telemetry) anchor to it.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Update the session's working directory. Used by the host when the user explicitly changes cwd (e.g., the `/cd` slash command). The host is responsible for any related side-effects (file index, etc.); it does NOT change the process working directory (a session's cwd is per-session, not process-global). For local sessions the runtime validates the target first (an absolute path that exists on disk) and re-bases the permission primary directory; a rejected validation fails the call before anything is mutated, persisted, or emitted. Location-scoped permission rules are then re-keyed to the new directory (best-effort). Remote sessions only record the path.</returns>
    public async Task<MetadataSetWorkingDirectoryResult> SetWorkingDirectoryAsync(string workingDirectory, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(workingDirectory);
        _session.ThrowIfDisposed();

        var request = new MetadataSetWorkingDirectoryRequest { SessionId = _session.SessionId, WorkingDirectory = workingDirectory };
        return await CopilotClient.InvokeRpcAsync<MetadataSetWorkingDirectoryResult>(_session.Rpc, "session.metadata.setWorkingDirectory", [request], cancellationToken);
    }

    /// <summary>Re-tokenizes the session's existing messages against a model and returns aggregate token totals.</summary>
    /// <param name="modelId">Model identifier used for tokenization. The runtime token-counts both chat-context and system-context messages against this model.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Re-tokenize the session's existing messages against `modelId` and return the token totals. Useful for hosts that want an initial estimate of context usage on session resume, before the next agent turn fires `session.context_info_changed` events. Returns zeros for an empty session.</returns>
    public async Task<MetadataRecomputeContextTokensResult> RecomputeContextTokensAsync(string modelId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(modelId);
        _session.ThrowIfDisposed();

        var request = new MetadataRecomputeContextTokensRequest { SessionId = _session.SessionId, ModelId = modelId };
        return await CopilotClient.InvokeRpcAsync<MetadataRecomputeContextTokensResult>(_session.Rpc, "session.metadata.recomputeContextTokens", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Settings APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class SettingsApi
{
    private readonly CopilotSession _session;

    internal SettingsApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Returns a redacted snapshot of session runtime settings, with secrets and raw feature flags excluded. Internal: the runtime settings shape is a runtime-internal surface and is deliberately kept out of the public SDK, because consumers should not depend on the runtime's internal settings layout. It remains callable in-process and is expected to be reworked as the runtime internals are consolidated.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Redacted, serializable view of session runtime settings for SDK boundary consumers. Secrets and raw feature flags are intentionally excluded.</returns>
    internal async Task<SessionSettingsSnapshot> SnapshotAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSettingsSnapshotRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<SessionSettingsSnapshot>(_session.Rpc, "session.settings.snapshot", [request], cancellationToken);
    }

    /// <summary>Evaluates a named Rust-owned settings predicate without exposing raw feature flags. Internal: the raw feature-flag names and composition are runtime-internal, so this predicate-evaluation helper is kept out of the public SDK surface and is callable in-process only.</summary>
    /// <param name="name">Predicate name. The runtime owns the raw feature-flag names and composition logic.</param>
    /// <param name="toolName">Tool name for tool-scoped predicates such as trivial-change handling.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of evaluating a Rust-owned settings predicate.</returns>
    internal async Task<SessionSettingsEvaluatePredicateResult> EvaluatePredicateAsync(SessionSettingsPredicateName name, string? toolName = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionSettingsEvaluatePredicateRequest { SessionId = _session.SessionId, Name = name, ToolName = toolName };
        return await CopilotClient.InvokeRpcAsync<SessionSettingsEvaluatePredicateResult>(_session.Rpc, "session.settings.evaluatePredicate", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped ContentExclusion APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ContentExclusionApi
{
    private readonly CopilotSession _session;

    internal ContentExclusionApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Checks local file system absolute paths within the session working directory against its content-exclusion policy. Results preserve input order. Unsupported paths/filesystems and unavailable policy evaluation return available false, and callers must treat every requested path as excluded.</summary>
    /// <param name="paths">Local file system absolute paths within the session working directory to check. Results are returned in the same order, including duplicates.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Batch content-exclusion result. Callers must fail closed when policy evaluation is unavailable.</returns>
    public async Task<ContentExclusionCheckPathsResult> CheckPathsAsync(IList<string> paths, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(paths);
        _session.ThrowIfDisposed();

        var request = new ContentExclusionCheckPathsRequest { SessionId = _session.SessionId, Paths = paths };
        return await CopilotClient.InvokeRpcAsync<ContentExclusionCheckPathsResult>(_session.Rpc, "session.contentExclusion.checkPaths", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Shell APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ShellApi
{
    private readonly CopilotSession _session;

    internal ShellApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Starts a shell command and streams output through session notifications. The command runs as the leader of its own process group (POSIX) or in a dedicated job object (Windows), so a forced termination — via "shell.kill", the request timeout, or session disposal — signals that whole group/job rather than only the direct child. Two gaps are worth planning for: a command that exits on its own does not trigger that teardown, and on POSIX a descendant that moves itself into a new session or process group (for example via "setsid") leaves the signalled group, so either can leave a background process running.</summary>
    /// <param name="command">Shell command to execute.</param>
    /// <param name="cwd">Working directory (defaults to session working directory).</param>
    /// <param name="timeout">Timeout in milliseconds (default: 30000).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Identifier of the spawned process, used to correlate streamed output and exit notifications.</returns>
    public async Task<ShellExecResult> ExecAsync(string command, string? cwd = null, TimeSpan? timeout = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(command);
        _session.ThrowIfDisposed();

        var request = new ShellExecRequest { SessionId = _session.SessionId, Command = command, Cwd = cwd, Timeout = timeout };
        return await CopilotClient.InvokeRpcAsync<ShellExecResult>(_session.Rpc, "session.shell.exec", [request], cancellationToken);
    }

    /// <summary>Sends a signal to a shell process previously started via "shell.exec". The signal targets the command's whole process group (POSIX) or job object (Windows), so descendants still in that group are signalled too, not just the direct child. On POSIX a descendant that moved itself into a new session or process group (for example via "setsid") is no longer in the signalled group and survives.</summary>
    /// <param name="processId">Process identifier returned by shell.exec.</param>
    /// <param name="signal">Signal to send (default: SIGTERM).</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the signal was delivered; false if the process was unknown or already exited.</returns>
    public async Task<ShellKillResult> KillAsync(string processId, ShellKillSignal? signal = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(processId);
        _session.ThrowIfDisposed();

        var request = new ShellKillRequest { SessionId = _session.SessionId, ProcessId = processId, Signal = signal };
        return await CopilotClient.InvokeRpcAsync<ShellKillResult>(_session.Rpc, "session.shell.kill", [request], cancellationToken);
    }

    /// <summary>Executes a user-requested shell command through the session runtime.</summary>
    /// <param name="requestId">Caller-provided cancellation handle for this execution.</param>
    /// <param name="command">Shell command to execute.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of a user-requested shell command.</returns>
    public async Task<UserRequestedShellCommandResult> ExecuteUserRequestedAsync(string requestId, string command, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        ArgumentNullException.ThrowIfNull(command);
        _session.ThrowIfDisposed();

        var request = new ShellExecuteUserRequestedRequest { SessionId = _session.SessionId, RequestId = requestId, Command = command };
        return await CopilotClient.InvokeRpcAsync<UserRequestedShellCommandResult>(_session.Rpc, "session.shell.executeUserRequested", [request], cancellationToken);
    }

    /// <summary>Cancels a user-requested shell command by request ID.</summary>
    /// <param name="requestId">Request ID previously passed to executeUserRequested.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Cancellation result for a user-requested shell command.</returns>
    public async Task<CancelUserRequestedShellCommandResult> CancelUserRequestedAsync(string requestId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(requestId);
        _session.ThrowIfDisposed();

        var request = new ShellCancelUserRequestedRequest { SessionId = _session.SessionId, RequestId = requestId };
        return await CopilotClient.InvokeRpcAsync<CancelUserRequestedShellCommandResult>(_session.Rpc, "session.shell.cancelUserRequested", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped History APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class HistoryApi
{
    private readonly CopilotSession _session;

    internal HistoryApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Compacts the session history to reduce context usage.</summary>
    /// <param name="request">Optional compaction parameters.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Compaction outcome with the number of tokens and messages removed, summary text, and the resulting context window breakdown.</returns>
    public async Task<HistoryCompactResult> CompactAsync(SessionHistoryCompactRequest? request = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var rpcRequest = new SessionHistoryCompactRequestWithSession { SessionId = _session.SessionId, CustomInstructions = request?.CustomInstructions, Trigger = request?.Trigger, TokenLimit = request?.TokenLimit };
        return await CopilotClient.InvokeRpcAsync<HistoryCompactResult>(_session.Rpc, "session.history.compact", [rpcRequest], cancellationToken);
    }

    /// <summary>Truncates persisted session history to a specific event.</summary>
    /// <param name="eventId">Event ID to truncate to. This event and all events after it are removed from the session.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Number of events that were removed by the truncation.</returns>
    public async Task<HistoryTruncateResult> TruncateAsync(string eventId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(eventId);
        _session.ThrowIfDisposed();

        var request = new HistoryTruncateRequest { SessionId = _session.SessionId, EventId = eventId };
        return await CopilotClient.InvokeRpcAsync<HistoryTruncateResult>(_session.Rpc, "session.history.truncate", [request], cancellationToken);
    }

    /// <summary>Lists the user turns that the session can rewind to. Never rejects for a busy session: rewind reads need the session's file-change captures to be settled, so a session that still holds active work answers with `unavailableReason: "session-busy"` and no points, which the caller can retry.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Rewind points and file-change-tracking availability for the session.</returns>
    public async Task<HistoryListRewindPointsResult> ListRewindPointsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionHistoryListRewindPointsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<HistoryListRewindPointsResult>(_session.Rpc, "session.history.listRewindPoints", [request], cancellationToken);
    }

    /// <summary>Previews the files that a conversation-and-files rewind would restore.</summary>
    /// <param name="eventId">ID of the user.message event that begins the discarded suffix.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Files and aggregate changes for a prospective rewind.</returns>
    public async Task<HistoryPreviewRewindResult> PreviewRewindAsync(string eventId, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(eventId);
        _session.ThrowIfDisposed();

        var request = new HistoryPreviewRewindRequest { SessionId = _session.SessionId, EventId = eventId };
        return await CopilotClient.InvokeRpcAsync<HistoryPreviewRewindResult>(_session.Rpc, "session.history.previewRewind", [request], cancellationToken);
    }

    /// <summary>Rewinds the session conversation, optionally restoring files changed by the discarded turns. Not crash-atomic: file restore and conversation truncation are separate stores, applied in that order, so a process crash between them can leave the workspace rewound while the conversation still contains the discarded turns. There is no recovery journal; re-running the same rewind is the recovery path for a crash before truncation lands, since file restore is idempotent (already-restored files are reported as skipped) and truncation is re-derived from the still-retained boundary event. After truncation lands that boundary no longer exists, so the same request is rejected; the only stage that can still be outstanding is snapshot pruning, whose failure leaves orphan snapshots the capture store tolerates. The reverse inconsistency cannot occur, because truncation is never applied before file restore succeeds.</summary>
    /// <param name="eventId">ID of the user.message event that begins the discarded suffix.</param>
    /// <param name="mode">Whether to rewind only conversation history or also restore captured files.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Structured outcome of a rewind request.</returns>
    public async Task<HistoryRewindResult> RewindAsync(string eventId, HistoryRewindMode mode, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(eventId);
        _session.ThrowIfDisposed();

        var request = new HistoryRewindRequest { SessionId = _session.SessionId, EventId = eventId, Mode = mode };
        return await CopilotClient.InvokeRpcAsync<HistoryRewindResult>(_session.Rpc, "session.history.rewind", [request], cancellationToken);
    }

    /// <summary>Cancels any in-progress background compaction on a local session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether an in-progress background compaction was cancelled.</returns>
    public async Task<HistoryCancelBackgroundCompactionResult> CancelBackgroundCompactionAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionHistoryCancelBackgroundCompactionRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<HistoryCancelBackgroundCompactionResult>(_session.Rpc, "session.history.cancelBackgroundCompaction", [request], cancellationToken);
    }

    /// <summary>Aborts any in-progress manual compaction on a local session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether an in-progress manual compaction was aborted.</returns>
    public async Task<HistoryAbortManualCompactionResult> AbortManualCompactionAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionHistoryAbortManualCompactionRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<HistoryAbortManualCompactionResult>(_session.Rpc, "session.history.abortManualCompaction", [request], cancellationToken);
    }

    /// <summary>Produces a markdown summary of the session's conversation context for hand-off scenarios.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Markdown summary of the conversation context (empty when not available).</returns>
    public async Task<HistorySummarizeForHandoffResult> SummarizeForHandoffAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionHistorySummarizeForHandoffRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<HistorySummarizeForHandoffResult>(_session.Rpc, "session.history.summarizeForHandoff", [request], cancellationToken);
    }

    /// <summary>Clears the session's conversation history, keeping only system and developer messages, and seeds the fresh context window with a first user message. Must be called from inside a tool handler: the clear has to drop the results of the tool calls its wipe orphans, and it rejects when no tool call is in flight.</summary>
    /// <param name="prompt">First user message of the fresh context window. Required: a cleared window holding only system and developer messages is not a conversation a model can answer, so every clear seeds the window it creates. Delivered by the enclosing turn driver once the agentic loop exits, which is why the call must be made from inside a tool handler.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>What a successful clear removed. A clear that could not be applied rejects instead of reporting a count.</returns>
    public async Task<HistoryClearContextResult> ClearContextAsync(string prompt, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new HistoryClearContextRequest { SessionId = _session.SessionId, Prompt = prompt };
        return await CopilotClient.InvokeRpcAsync<HistoryClearContextResult>(_session.Rpc, "session.history.clearContext", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Queue APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class QueueApi
{
    private readonly CopilotSession _session;

    internal QueueApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Returns the local session's pending user-facing queued items and steering messages.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Snapshot of the session's pending queued items and immediate-steering messages.</returns>
    public async Task<QueuePendingItemsResult> PendingItemsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionQueuePendingItemsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<QueuePendingItemsResult>(_session.Rpc, "session.queue.pendingItems", [request], cancellationToken);
    }

    /// <summary>Returns the internal native queue snapshot for in-process session orchestration.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Internal snapshot of native queue state for local session orchestration.</returns>
    internal async Task<QueueSnapshotResult> SnapshotAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionQueueSnapshotRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<QueueSnapshotResult>(_session.Rpc, "session.queue.snapshot", [request], cancellationToken);
    }

    /// <summary>Moves an addressable queued item to a public visible position.</summary>
    /// <param name="id">Stable opaque queued-item id.</param>
    /// <param name="toPosition">Zero-based target position in the public visible queue. Values outside the queue clamp to an end.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of moving a queued item.</returns>
    public async Task<QueueMoveItemResult> MoveItemAsync(string id, long toPosition, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new QueueMoveItemRequest { SessionId = _session.SessionId, Id = id, ToPosition = toPosition };
        return await CopilotClient.InvokeRpcAsync<QueueMoveItemResult>(_session.Rpc, "session.queue.moveItem", [request], cancellationToken);
    }

    /// <summary>Inserts a new queued message at a public visible position.</summary>
    /// <param name="position">Zero-based position in the public visible queue. Values outside the queue clamp to an end.</param>
    /// <param name="message">Queued message contents and delivery metadata.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of inserting a queued message.</returns>
    public async Task<QueueInsertAtResult> InsertAtAsync(long position, QueueInsertMessage message, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(message);
        _session.ThrowIfDisposed();

        var request = new QueueInsertAtRequest { SessionId = _session.SessionId, Position = position, Message = message };
        return await CopilotClient.InvokeRpcAsync<QueueInsertAtResult>(_session.Rpc, "session.queue.insertAt", [request], cancellationToken);
    }

    /// <summary>Removes an addressable queued item by its stable id.</summary>
    /// <param name="id">Stable opaque ID of the queued item to remove.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of removing a queued item.</returns>
    public async Task<QueueRemoveAtResult> RemoveAtAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new QueueRemoveAtRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<QueueRemoveAtResult>(_session.Rpc, "session.queue.removeAt", [request], cancellationToken);
    }

    /// <summary>Updates the text of an addressable single-message queue item.</summary>
    /// <param name="id">Stable opaque ID of the queued item to edit.</param>
    /// <param name="prompt">Replacement prompt sent to the model.</param>
    /// <param name="displayPrompt">Optional replacement prompt displayed to the user.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of editing a queued message.</returns>
    public async Task<QueueUpdateTextResult> UpdateTextAsync(string id, string prompt, string? displayPrompt = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new QueueUpdateTextRequest { SessionId = _session.SessionId, Id = id, Prompt = prompt, DisplayPrompt = displayPrompt };
        return await CopilotClient.InvokeRpcAsync<QueueUpdateTextResult>(_session.Rpc, "session.queue.updateText", [request], cancellationToken);
    }

    /// <summary>Duplicates an addressable queued item immediately after its source.</summary>
    /// <param name="id">Stable opaque ID of the queued item to duplicate.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of duplicating a queued item.</returns>
    public async Task<QueueDuplicateAtResult> DuplicateAtAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new QueueDuplicateAtRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<QueueDuplicateAtResult>(_session.Rpc, "session.queue.duplicateAt", [request], cancellationToken);
    }

    /// <summary>Acquires or releases the queued-lane drain pause.</summary>
    /// <param name="paused">Whether queued-lane draining should be paused.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task SetDrainPausedAsync(bool paused, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new QueueSetDrainPausedRequest { SessionId = _session.SessionId, Paused = paused };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.queue.setDrainPaused", [request], cancellationToken);
    }

    /// <summary>Moves an addressable queued message into the live turn's steering lane.</summary>
    /// <param name="id">Stable opaque ID of the queued item to steer into the live turn.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of trying to steer a queued message into a live turn.</returns>
    public async Task<QueueSendNowResult> SendNowAsync(string id, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(id);
        _session.ThrowIfDisposed();

        var request = new QueueSendNowRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<QueueSendNowResult>(_session.Rpc, "session.queue.sendNow", [request], cancellationToken);
    }

    /// <summary>Reports whether the local session has native queued work pending.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the native queue has pending work.</returns>
    internal async Task<QueueHasPendingResult> HasPendingAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionQueueHasPendingRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<QueueHasPendingResult>(_session.Rpc, "session.queue.hasPending", [request], cancellationToken);
    }

    /// <summary>Begins a native deferred-idle drain when background work has quiesced.</summary>
    /// <param name="activeBackgroundWork">Whether the host still has active background work.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether a deferred-idle drain should run.</returns>
    internal async Task<QueueBeginDeferredIdleDrainResult> BeginDeferredIdleDrainAsync(bool activeBackgroundWork, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new QueueBeginDeferredIdleDrainRequest { SessionId = _session.SessionId, ActiveBackgroundWork = activeBackgroundWork };
        return await CopilotClient.InvokeRpcAsync<QueueBeginDeferredIdleDrainResult>(_session.Rpc, "session.queue.beginDeferredIdleDrain", [request], cancellationToken);
    }

    /// <summary>Finishes a native deferred-idle drain and reports whether to drain queue work or emit idle.</summary>
    /// <param name="activeBackgroundWork">Whether the host still has active background work.</param>
    /// <param name="hasPending">Whether native queued work remains.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Action selected by the native deferred-idle drain.</returns>
    internal async Task<QueueFinishDeferredIdleDrainResult> FinishDeferredIdleDrainAsync(bool activeBackgroundWork, bool hasPending, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new QueueFinishDeferredIdleDrainRequest { SessionId = _session.SessionId, ActiveBackgroundWork = activeBackgroundWork, HasPending = hasPending };
        return await CopilotClient.InvokeRpcAsync<QueueFinishDeferredIdleDrainResult>(_session.Rpc, "session.queue.finishDeferredIdleDrain", [request], cancellationToken);
    }

    /// <summary>Marks session.idle as deferred by native background work state.</summary>
    /// <param name="aborted">Whether the deferred idle was caused by an aborted foreground turn.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task DeferSessionIdleAsync(bool aborted, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new QueueDeferSessionIdleRequest { SessionId = _session.SessionId, Aborted = aborted };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.queue.deferSessionIdle", [request], cancellationToken);
    }

    /// <summary>Removes the most recently queued user-facing item (LIFO).</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether a user-facing pending item was removed.</returns>
    public async Task<QueueRemoveMostRecentResult> RemoveMostRecentAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionQueueRemoveMostRecentRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<QueueRemoveMostRecentResult>(_session.Rpc, "session.queue.removeMostRecent", [request], cancellationToken);
    }

    /// <summary>Clears all pending queued items on the local session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task ClearAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionQueueClearRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.queue.clear", [request], cancellationToken);
    }

    /// <summary>Consumes queued native system notifications matching an internal filter.</summary>
    /// <param name="filter">Opaque runtime-owned filter object.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether a user-facing pending item was removed.</returns>
    internal async Task<QueueRemoveMostRecentResult> ConsumeSystemNotificationsAsync(object filter, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(filter);
        _session.ThrowIfDisposed();

        var request = new QueueConsumeSystemNotificationsRequest { SessionId = _session.SessionId, Filter = CopilotClient.ToJsonElementForWire(filter)!.Value };
        return await CopilotClient.InvokeRpcAsync<QueueRemoveMostRecentResult>(_session.Rpc, "session.queue.consumeSystemNotifications", [request], cancellationToken);
    }

    /// <summary>Enqueues the internal resume-pending wake item when orphan handling needs a follow-up turn.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of enqueueing the resume-pending wake item.</returns>
    internal async Task<QueueEnqueueResumePendingResult> EnqueueResumePendingAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionQueueEnqueueResumePendingRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<QueueEnqueueResumePendingResult>(_session.Rpc, "session.queue.enqueueResumePending", [request], cancellationToken);
    }

    /// <summary>Drains the native local-session work queue for in-process session orchestration.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task ProcessAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionQueueProcessRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.queue.process", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped EventLog APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class EventLogApi
{
    private readonly CopilotSession _session;

    internal EventLogApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Reads a batch of session events from a cursor, optionally waiting for new events. Supports tail-first reads via `direction: backward`.</summary>
    /// <param name="cursor">Opaque cursor returned by a previous read. Omit on the first call to start from the beginning of the session's persisted history.</param>
    /// <param name="max">Maximum number of events to return in this batch (1–1000, default 200).</param>
    /// <param name="waitMs">Milliseconds to wait for new events when the cursor is at the tail of history. 0 (default) returns immediately even if no events are available. Capped at 30000ms. Ephemeral events that arrive during the wait are delivered in this batch but are NOT replayable on a subsequent read (use a non-zero waitMs in your next call to capture future ephemerals as they happen). This applies to forward reads only: a backward read always returns immediately and ignores `waitMs`, because backward paging covers persisted history only while new events append at the tail (the opposite end from a backward page), so no blocking or ephemeral delivery can occur.</param>
    /// <param name="types">Either '*' to receive all event types, or a non-empty list of event types to receive.</param>
    /// <param name="agentScope">Agent-scope filter: 'primary' returns only main-agent events plus events whose type starts with 'subagent.' (matching the typed-subscription default behavior); 'all' returns events from all agents (matching wildcard-subscription behavior). Default is 'all' to preserve wildcard semantics for catch-up callers.</param>
    /// <param name="agentIds">Optional non-empty list of subagent identifiers. When provided, only events owned by one of these agents are returned; ownership recognizes the event envelope's agentId plus legacy data.agentId and data.parentToolCallId markers. This filter takes precedence over agentScope.</param>
    /// <param name="direction">Direction to page through the session's persisted event history. 'forward' (default) pages from the cursor toward newer events (or from the start of history when no cursor is given). 'backward' enables tail-first reads: with no cursor it returns the NEWEST `max` events, and the returned cursor pages toward OLDER events on subsequent backward reads. Events within a returned batch are always in chronological (oldest-to-newest) order, even for a backward read. Backward reads cover PERSISTED history only; ephemeral events are never returned by a backward read. `direction` selects the INITIAL read only: the returned cursor is self-describing, so a continuation read pages in the cursor's own direction regardless of the `direction` passed alongside it — a forward cursor always pages forward and a backward cursor always pages backward. Pass the direction that matches the cursor to avoid confusion.</param>
    /// <param name="includeEphemeral">When false, skip ephemeral events entirely and return only durable (persisted) events. History-backfill callers that discard ephemerals anyway should set this so the read is bounded by the durable log length instead of racing the ephemeral ring on a busy session. Defaults to true (ephemerals are interleaved with durable events in creation order). Ignored by backward reads, which always cover persisted history only.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Batch of session events returned by a read, with cursor and continuation metadata.</returns>
    public async Task<EventsReadResult> ReadAsync(string? cursor = null, long? max = null, TimeSpan? waitMs = null, object? types = null, EventsAgentScope? agentScope = null, IList<string>? agentIds = null, EventsReadDirection? direction = null, bool? includeEphemeral = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new EventLogReadRequest { SessionId = _session.SessionId, Cursor = cursor, Max = max, Wait = waitMs, Types = CopilotClient.ToJsonElementForWire(types), AgentScope = agentScope, AgentIds = agentIds, Direction = direction, IncludeEphemeral = includeEphemeral };
        return await CopilotClient.InvokeRpcAsync<EventsReadResult>(_session.Rpc, "session.eventLog.read", [request], cancellationToken);
    }

    /// <summary>Returns a snapshot of the current tail cursor without consuming events.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Snapshot of the current tail cursor without returning any events. Use this when a consumer wants to subscribe to live events going forward without first paginating through the entire persisted history (which would happen if `read` were called without a cursor on a long-lived session).</returns>
    public async Task<EventLogTailResult> TailAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionEventLogTailRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<EventLogTailResult>(_session.Rpc, "session.eventLog.tail", [request], cancellationToken);
    }

    /// <summary>Registers consumer interest in an event type for runtime gating purposes.</summary>
    /// <param name="eventType">The event type the consumer wants the runtime to treat as 'observed' for behavior-switching gating. Some runtime code paths inspect whether any consumer is interested in a specific event type and choose a different implementation accordingly (e.g. `mcp.oauth_required`: when interest is registered the runtime delegates interactive OAuth token acquisition to the consumer via `mcp.oauth_required` events; when no interest is registered the runtime still attempts non-interactive reconnect from cached or refreshable tokens, and only marks the server `needs-auth` if usable credentials are unavailable — it does not open a browser or start interactive OAuth without a consumer). SDK clients that long-poll events do NOT automatically appear as listeners to these gating checks — they must explicitly call `registerInterest` for each event type they want the runtime to count as having a consumer. Multiple registrations for the same event type from the same or different consumers are tracked independently and must each be released. See: `mcp.oauth_required`, `sampling.requested`, `auto_mode_switch.requested`, `session_limits_exhausted.requested`, `user_input.requested`, `elicitation.requested`, `command.queued`, `exit_plan_mode.requested`.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Opaque handle representing an event-type interest registration.</returns>
    public async Task<RegisterEventInterestResult> RegisterInterestAsync(string eventType, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(eventType);
        _session.ThrowIfDisposed();

        var request = new RegisterEventInterestParams { SessionId = _session.SessionId, EventType = eventType };
        return await CopilotClient.InvokeRpcAsync<RegisterEventInterestResult>(_session.Rpc, "session.eventLog.registerInterest", [request], cancellationToken);
    }

    /// <summary>Releases a consumer's previously-registered interest in an event type.</summary>
    /// <param name="handle">Handle returned by a previous `registerInterest` call. Idempotent: releasing an unknown or already-released handle is a no-op (returns success). When the last outstanding handle for an event type is released, the runtime reverts to its 'no consumer' code path for that event type.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the operation succeeded.</returns>
    public async Task<EventLogReleaseInterestResult> ReleaseInterestAsync(string handle, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(handle);
        _session.ThrowIfDisposed();

        var request = new ReleaseEventInterestParams { SessionId = _session.SessionId, Handle = handle };
        return await CopilotClient.InvokeRpcAsync<EventLogReleaseInterestResult>(_session.Rpc, "session.eventLog.releaseInterest", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Usage APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class UsageApi
{
    private readonly CopilotSession _session;

    internal UsageApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Gets accumulated usage metrics for the session.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Accumulated session usage metrics, including premium request cost, token counts, model breakdown, and code-change totals.</returns>
    public async Task<UsageGetMetricsResult> GetMetricsAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionUsageGetMetricsRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<UsageGetMetricsResult>(_session.Rpc, "session.usage.getMetrics", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped LimitPrediction APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class LimitPredictionApi
{
    private readonly CopilotSession _session;

    internal LimitPredictionApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Predicts an AI-credit session limit for the session's resolved model. Returns an unavailable result instead of falling back when the current model is unresolved auto.</summary>
    /// <param name="request">Parameters for predicting an AI-credit session limit. Omitting `modelId` uses the session's currently selected model.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Prediction result. Available results include prediction details; unavailable results include an explicit reason.</returns>
    public async Task<SessionLimitPredictionResult> PredictAsync(SessionLimitPredictionPredictRequest? request = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var rpcRequest = new SessionLimitPredictionPredictRequestWithSession { SessionId = _session.SessionId, ModelId = request?.ModelId, ClientType = request?.ClientType };
        return await CopilotClient.InvokeRpcAsync<SessionLimitPredictionResult>(_session.Rpc, "session.limitPrediction.predict", [rpcRequest], cancellationToken);
    }
}

/// <summary>Provides session-scoped Remote APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class RemoteApi
{
    private readonly CopilotSession _session;

    internal RemoteApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Enables remote session export or steering.</summary>
    /// <param name="mode">Per-session remote mode. "off" disables remote, "export" exports session events to GitHub without enabling remote steering, "on" enables both export and remote steering.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>GitHub URL for the session and a flag indicating whether remote steering is enabled.</returns>
    public async Task<RemoteEnableResult> EnableAsync(RemoteSessionMode? mode = null, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new RemoteEnableRequest { SessionId = _session.SessionId, Mode = mode };
        return await CopilotClient.InvokeRpcAsync<RemoteEnableResult>(_session.Rpc, "session.remote.enable", [request], cancellationToken);
    }

    /// <summary>Disables remote session export and steering.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    public async Task DisableAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionRemoteDisableRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.remote.disable", [request], cancellationToken);
    }

    /// <summary>Persists a remote-steerability change emitted by the host as a session event.</summary>
    /// <param name="remoteSteerable">Whether the session now supports remote steering via GitHub. The runtime persists this as a `session.remote_steerable_changed` event so resume/replay sees the up-to-date capability.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Persist a steerability change as a `session.remote_steerable_changed` event. Used by the host (CLI / SDK consumer) when it has just finished enabling or disabling steering on a remote exporter that the runtime does not directly own.</returns>
    public async Task<RemoteNotifySteerableChangedResult> NotifySteerableChangedAsync(bool remoteSteerable, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new RemoteNotifySteerableChangedRequest { SessionId = _session.SessionId, RemoteSteerable = remoteSteerable };
        return await CopilotClient.InvokeRpcAsync<RemoteNotifySteerableChangedResult>(_session.Rpc, "session.remote.notifySteerableChanged", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Visibility APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class VisibilityApi
{
    private readonly CopilotSession _session;

    internal VisibilityApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Returns the session's current Mission Control sharing status and shareable GitHub URL. Reflects whether the synced session is visible to repository readers ("repo") or restricted to its creator and collaborators ("unshared").</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Current sharing status and shareable GitHub URL for a session.</returns>
    public async Task<VisibilityGetResult> GetAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionVisibilityGetRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<VisibilityGetResult>(_session.Rpc, "session.visibility.get", [request], cancellationToken);
    }

    /// <summary>Sets the session's Mission Control sharing status, controlling whether the synced session is visible to repository readers. Returns the effective status and shareable GitHub URL after the change.</summary>
    /// <param name="status">Sharing status to apply. "repo" makes the session visible to repository readers; "unshared" restricts it to the creator and collaborators.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Effective sharing status and shareable GitHub URL after updating session visibility.</returns>
    public async Task<VisibilitySetResult> SetAsync(SessionVisibilityStatus status, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new VisibilitySetRequest { SessionId = _session.SessionId, Status = status };
        return await CopilotClient.InvokeRpcAsync<VisibilitySetResult>(_session.Rpc, "session.visibility.set", [request], cancellationToken);
    }
}

/// <summary>Provides session-scoped Schedule APIs.</summary>
[Experimental(Diagnostics.Experimental)]
public sealed class ScheduleApi
{
    private readonly CopilotSession _session;

    internal ScheduleApi(CopilotSession session)
    {
        _session = session;
    }

    /// <summary>Lists the session's currently active scheduled prompts.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Snapshot of the currently active recurring prompts for this session.</returns>
    public async Task<ScheduleList> ListAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionScheduleListRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<ScheduleList>(_session.Rpc, "session.schedule.list", [request], cancellationToken);
    }

    /// <summary>Hydrates the native schedule registry from persisted session events.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    internal async Task HydrateAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionScheduleHydrateRequest { SessionId = _session.SessionId };
        await CopilotClient.InvokeRpcAsync(_session.Rpc, "session.schedule.hydrate", [request], cancellationToken);
    }

    /// <summary>Reports whether the session has an active self-paced scheduled prompt.</summary>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the session currently has an active self-paced schedule.</returns>
    internal async Task<ScheduleHasSelfPacedResult> HasSelfPacedAsync(CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new SessionScheduleHasSelfPacedRequest { SessionId = _session.SessionId };
        return await CopilotClient.InvokeRpcAsync<ScheduleHasSelfPacedResult>(_session.Rpc, "session.schedule.hasSelfPaced", [request], cancellationToken);
    }

    /// <summary>Registers a relative-interval scheduled prompt.</summary>
    /// <param name="interval">Human-readable interval such as `30s`, `5m`, or `2h`.</param>
    /// <param name="prompt">Prompt text to enqueue when the schedule fires.</param>
    /// <param name="recurring">Whether the schedule should re-arm after each tick. Defaults to true.</param>
    /// <param name="displayPrompt">Optional display-only prompt label.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of registering or re-arming a scheduled prompt.</returns>
    internal async Task<ScheduleAddResult> AddAsync(string interval, string prompt, bool? recurring = null, string? displayPrompt = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(interval);
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new ScheduleAddRequest { SessionId = _session.SessionId, Interval = interval, Prompt = prompt, Recurring = recurring, DisplayPrompt = displayPrompt };
        return await CopilotClient.InvokeRpcAsync<ScheduleAddResult>(_session.Rpc, "session.schedule.add", [request], cancellationToken);
    }

    /// <summary>Registers a recurring cron scheduled prompt.</summary>
    /// <param name="cron">5-field cron expression.</param>
    /// <param name="prompt">Prompt text to enqueue when the schedule fires.</param>
    /// <param name="recurring">Whether the schedule should re-arm after each tick. Defaults to true.</param>
    /// <param name="displayPrompt">Optional display-only prompt label.</param>
    /// <param name="tz">IANA timezone for evaluating the cron expression.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of registering or re-arming a scheduled prompt.</returns>
    internal async Task<ScheduleAddResult> AddCronAsync(string cron, string prompt, bool? recurring = null, string? displayPrompt = null, string? tz = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(cron);
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new ScheduleAddCronRequest { SessionId = _session.SessionId, Cron = cron, Prompt = prompt, Recurring = recurring, DisplayPrompt = displayPrompt, Tz = tz };
        return await CopilotClient.InvokeRpcAsync<ScheduleAddResult>(_session.Rpc, "session.schedule.addCron", [request], cancellationToken);
    }

    /// <summary>Registers an absolute-time scheduled prompt.</summary>
    /// <param name="at">Epoch milliseconds when the prompt should fire.</param>
    /// <param name="prompt">Prompt text to enqueue when the schedule fires.</param>
    /// <param name="recurring">Whether the schedule should re-arm after each tick. Defaults to false.</param>
    /// <param name="displayPrompt">Optional display-only prompt label.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of registering or re-arming a scheduled prompt.</returns>
    internal async Task<ScheduleAddResult> AddAtAsync(long at, string prompt, bool? recurring = null, string? displayPrompt = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new ScheduleAddAtRequest { SessionId = _session.SessionId, At = at, Prompt = prompt, Recurring = recurring, DisplayPrompt = displayPrompt };
        return await CopilotClient.InvokeRpcAsync<ScheduleAddResult>(_session.Rpc, "session.schedule.addAt", [request], cancellationToken);
    }

    /// <summary>Registers a self-paced scheduled prompt.</summary>
    /// <param name="prompt">Prompt text to enqueue when the schedule fires.</param>
    /// <param name="displayPrompt">Optional display-only prompt label.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of registering or re-arming a scheduled prompt.</returns>
    internal async Task<ScheduleAddResult> AddSelfPacedAsync(string prompt, string? displayPrompt = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(prompt);
        _session.ThrowIfDisposed();

        var request = new ScheduleAddSelfPacedRequest { SessionId = _session.SessionId, Prompt = prompt, DisplayPrompt = displayPrompt };
        return await CopilotClient.InvokeRpcAsync<ScheduleAddResult>(_session.Rpc, "session.schedule.addSelfPaced", [request], cancellationToken);
    }

    /// <summary>Re-arms an active self-paced scheduled prompt.</summary>
    /// <param name="id">Id of the self-paced scheduled prompt.</param>
    /// <param name="at">Epoch milliseconds when the prompt should next fire.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result of registering or re-arming a scheduled prompt.</returns>
    internal async Task<ScheduleAddResult> RearmSelfPacedAsync(long id, long at, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ScheduleRearmSelfPacedRequest { SessionId = _session.SessionId, Id = id, At = at };
        return await CopilotClient.InvokeRpcAsync<ScheduleAddResult>(_session.Rpc, "session.schedule.rearmSelfPaced", [request], cancellationToken);
    }

    /// <summary>Removes a scheduled prompt by id.</summary>
    /// <param name="id">Id of the scheduled prompt to remove.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Remove a scheduled prompt by id. The result entry is omitted if the id was unknown.</returns>
    public async Task<ScheduleStopResult> StopAsync(long id, CancellationToken cancellationToken = default)
    {
        _session.ThrowIfDisposed();

        var request = new ScheduleStopRequest { SessionId = _session.SessionId, Id = id };
        return await CopilotClient.InvokeRpcAsync<ScheduleStopResult>(_session.Rpc, "session.schedule.stop", [request], cancellationToken);
    }
}

/// <summary>Handles `providerToken` client session API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface IProviderTokenHandler
{
    /// <summary>Asks the SDK client to get a bearer token for a BYOK provider whose config set `hasBearerTokenProvider: true`. Session-scoped: the runtime calls it back on the connection that most recently supplied that provider's config for the session (the creating connection, or a resuming connection if the session was resumed — distinct providers may be owned by different connections), passing the provider name, and uses the returned token as the Authorization header for the outbound model request. The runtime does no caching — it calls this once per outbound request; the SDK consumer owns token acquisition, caching, and refresh.</summary>
    /// <param name="request">Asks the SDK client to acquire a bearer token for a BYOK provider whose config set `hasBearerTokenProvider: true`. Issued by the runtime before each outbound model request; the runtime does no caching, so this is sent once per request.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>A bearer token supplied by the SDK client for a BYOK provider. The runtime sets it as `Authorization: Bearer &lt;token&gt;` on the outbound request and does no caching; the SDK consumer owns token caching and refresh.</returns>
    Task<ProviderTokenAcquireResult> GetTokenAsync(ProviderTokenAcquireRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Handles `factory` client session API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface IFactoryHandler
{
    /// <summary>Asks the owning extension connection to execute a registered factory closure.</summary>
    /// <param name="request">Parameters sent to the owning extension to execute a factory closure.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Result returned by an extension factory closure.</returns>
    Task<FactoryExecuteResult> ExecuteAsync(FactoryExecuteRequest request, CancellationToken cancellationToken = default);
    /// <summary>Asks the owning extension connection to abort a running factory cooperatively.</summary>
    /// <param name="request">Parameters for cooperatively aborting a factory body.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Acknowledgement that a factory request was accepted.</returns>
    Task<FactoryAckResult> AbortAsync(FactoryAbortRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Handles `tasks` client session API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface ITasksHandler
{
    /// <summary>Asks the client currently bound to a client-owned session task to confirm that its external work stopped.</summary>
    /// <param name="request">Runtime-to-owner cancellation request for a client-owned task.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Whether the client authoritatively confirmed its external work stopped.</returns>
    Task<ClientTaskCancelResult> CancelAsync(ClientTaskCancelRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Handles `sessionFs` client session API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface ISessionFsHandler
{
    /// <summary>Reads a file from the client-provided session filesystem.</summary>
    /// <param name="request">Path of the file to read from the client-provided session filesystem.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>File content as a UTF-8 string, or a filesystem error if the read failed.</returns>
    Task<SessionFsReadFileResult> ReadFileAsync(SessionFsReadFileRequest request, CancellationToken cancellationToken = default);
    /// <summary>Writes a file in the client-provided session filesystem.</summary>
    /// <param name="request">File path, content to write, and optional mode for the client-provided session filesystem.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Describes a filesystem error.</returns>
    Task<SessionFsError?> WriteFileAsync(SessionFsWriteFileRequest request, CancellationToken cancellationToken = default);
    /// <summary>Appends content to a file in the client-provided session filesystem, creating parent directories as needed.</summary>
    /// <param name="request">File path, content to append, and optional mode for the client-provided session filesystem. Implementations create parent directories as needed.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Describes a filesystem error.</returns>
    Task<SessionFsError?> AppendFileAsync(SessionFsAppendFileRequest request, CancellationToken cancellationToken = default);
    /// <summary>Checks whether a path exists in the client-provided session filesystem.</summary>
    /// <param name="request">Path to test for existence in the client-provided session filesystem.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the requested path exists in the client-provided session filesystem.</returns>
    Task<SessionFsExistsResult> ExistsAsync(SessionFsExistsRequest request, CancellationToken cancellationToken = default);
    /// <summary>Gets metadata for a path in the client-provided session filesystem.</summary>
    /// <param name="request">Path whose metadata should be returned from the client-provided session filesystem.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Filesystem metadata for the requested path, or a filesystem error if the stat failed.</returns>
    Task<SessionFsStatResult> StatAsync(SessionFsStatRequest request, CancellationToken cancellationToken = default);
    /// <summary>Creates a directory in the client-provided session filesystem.</summary>
    /// <param name="request">Directory path to create in the client-provided session filesystem, with options for recursive creation and POSIX mode.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Describes a filesystem error.</returns>
    Task<SessionFsError?> MkdirAsync(SessionFsMkdirRequest request, CancellationToken cancellationToken = default);
    /// <summary>Lists entry names in a directory from the client-provided session filesystem.</summary>
    /// <param name="request">Directory path whose entries should be listed from the client-provided session filesystem.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Names of entries in the requested directory, or a filesystem error if the read failed.</returns>
    Task<SessionFsReaddirResult> ReaddirAsync(SessionFsReaddirRequest request, CancellationToken cancellationToken = default);
    /// <summary>Lists directory entries with type information from the client-provided session filesystem.</summary>
    /// <param name="request">Directory path whose entries (with type information) should be listed from the client-provided session filesystem.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Entries in the requested directory paired with file/directory type information, or a filesystem error if the read failed.</returns>
    Task<SessionFsReaddirWithTypesResult> ReaddirWithTypesAsync(SessionFsReaddirWithTypesRequest request, CancellationToken cancellationToken = default);
    /// <summary>Removes a file or directory from the client-provided session filesystem.</summary>
    /// <param name="request">Path to remove from the client-provided session filesystem, with options for recursive removal and force.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Describes a filesystem error.</returns>
    Task<SessionFsError?> RmAsync(SessionFsRmRequest request, CancellationToken cancellationToken = default);
    /// <summary>Renames or moves a path in the client-provided session filesystem.</summary>
    /// <param name="request">Source and destination paths for renaming or moving an entry in the client-provided session filesystem.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Describes a filesystem error.</returns>
    Task<SessionFsError?> RenameAsync(SessionFsRenameRequest request, CancellationToken cancellationToken = default);
    /// <summary>Executes a SQLite query against the per-session database. Providers apply busy handling for every call.</summary>
    /// <param name="request">SQL query, query type, and optional bind parameters for executing a SQLite query against the per-session database. The provider applies its SQLite busy timeout for every call.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Query results including rows, columns, and rows affected, or a filesystem error if execution failed.</returns>
    Task<SessionFsSqliteQueryResult> SqliteQueryAsync(SessionFsSqliteQueryRequest request, CancellationToken cancellationToken = default);
    /// <summary>Executes SQLite statements atomically on the provider-owned connection.</summary>
    /// <param name="request">Statements to execute atomically. Providers apply busy handling for every call.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Per-statement results, or a classified transaction error.</returns>
    Task<SessionFsSqliteTransactionResult> SqliteTransactionAsync(SessionFsSqliteTransactionRequest request, CancellationToken cancellationToken = default);
    /// <summary>Checks whether the per-session SQLite database already exists, without creating it.</summary>
    /// <param name="request">Identifies the target session.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Indicates whether the per-session SQLite database already exists.</returns>
    Task<SessionFsSqliteExistsResult> SqliteExistsAsync(SessionFsSqliteExistsRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Handles `canvas` client session API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface ICanvasHandler
{
    /// <summary>Opens a canvas instance on the provider.</summary>
    /// <param name="request">Canvas open parameters sent to the provider.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Canvas open result returned by the provider.</returns>
    Task<CanvasProviderOpenResult> OpenAsync(CanvasProviderOpenRequest request, CancellationToken cancellationToken = default);
    /// <summary>Closes a canvas instance on the provider.</summary>
    /// <param name="request">Canvas close parameters sent to the provider.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    Task CloseAsync(CanvasProviderCloseRequest request, CancellationToken cancellationToken = default);
    /// <summary>Invokes an action on an open canvas instance via the provider.</summary>
    /// <param name="request">Canvas action invocation parameters sent to the provider.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Provider-supplied action result.</returns>
    Task<object> InvokeAsync(CanvasProviderInvokeActionRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Provides all client session API handler groups for a session.</summary>
public sealed class ClientSessionApiHandlers
{
    /// <summary>Optional handler for ProviderToken client session API methods.</summary>
    public IProviderTokenHandler? ProviderToken { get; set; }

    /// <summary>Optional handler for Factory client session API methods.</summary>
    public IFactoryHandler? Factory { get; set; }

    /// <summary>Optional handler for Tasks client session API methods.</summary>
    public ITasksHandler? Tasks { get; set; }

    /// <summary>Optional handler for SessionFs client session API methods.</summary>
    public ISessionFsHandler? SessionFs { get; set; }

    /// <summary>Optional handler for Canvas client session API methods.</summary>
    public ICanvasHandler? Canvas { get; set; }
}

/// <summary>Registers client session API handlers on a JSON-RPC connection.</summary>
internal static class ClientSessionApiRegistration
{
    /// <summary>
    /// Registers handlers for server-to-client session API calls.
    /// Each incoming call includes a <c>sessionId</c> in its params object,
    /// which is used to resolve the session's handler group.
    /// </summary>
    public static void RegisterClientSessionApiHandlers(JsonRpc rpc, Func<string, ClientSessionApiHandlers> getHandlers)
    {
        rpc.SetLocalRpcMethod("providerToken.getToken", (Func<ProviderTokenAcquireRequest, CancellationToken, ValueTask<ProviderTokenAcquireResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).ProviderToken;
            if (handler is null) throw new InvalidOperationException($"No providerToken handler registered for session: {request.SessionId}");
            return await handler.GetTokenAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("factory.execute", (Func<FactoryExecuteRequest, CancellationToken, ValueTask<FactoryExecuteResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).Factory;
            if (handler is null) throw new InvalidOperationException($"No factory handler registered for session: {request.SessionId}");
            return await handler.ExecuteAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("factory.abort", (Func<FactoryAbortRequest, CancellationToken, ValueTask<FactoryAckResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).Factory;
            if (handler is null) throw new InvalidOperationException($"No factory handler registered for session: {request.SessionId}");
            return await handler.AbortAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("tasks.cancel", (Func<ClientTaskCancelRequest, CancellationToken, ValueTask<ClientTaskCancelResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).Tasks;
            if (handler is null) throw new InvalidOperationException($"No tasks handler registered for session: {request.SessionId}");
            return await handler.CancelAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.readFile", (Func<SessionFsReadFileRequest, CancellationToken, ValueTask<SessionFsReadFileResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.ReadFileAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.writeFile", (Func<SessionFsWriteFileRequest, CancellationToken, ValueTask<SessionFsError?>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.WriteFileAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.appendFile", (Func<SessionFsAppendFileRequest, CancellationToken, ValueTask<SessionFsError?>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.AppendFileAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.exists", (Func<SessionFsExistsRequest, CancellationToken, ValueTask<SessionFsExistsResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.ExistsAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.stat", (Func<SessionFsStatRequest, CancellationToken, ValueTask<SessionFsStatResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.StatAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.mkdir", (Func<SessionFsMkdirRequest, CancellationToken, ValueTask<SessionFsError?>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.MkdirAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.readdir", (Func<SessionFsReaddirRequest, CancellationToken, ValueTask<SessionFsReaddirResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.ReaddirAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.readdirWithTypes", (Func<SessionFsReaddirWithTypesRequest, CancellationToken, ValueTask<SessionFsReaddirWithTypesResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.ReaddirWithTypesAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.rm", (Func<SessionFsRmRequest, CancellationToken, ValueTask<SessionFsError?>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.RmAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.rename", (Func<SessionFsRenameRequest, CancellationToken, ValueTask<SessionFsError?>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.RenameAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.sqliteQuery", (Func<SessionFsSqliteQueryRequest, CancellationToken, ValueTask<SessionFsSqliteQueryResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.SqliteQueryAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.sqliteTransaction", (Func<SessionFsSqliteTransactionRequest, CancellationToken, ValueTask<SessionFsSqliteTransactionResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.SqliteTransactionAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("sessionFs.sqliteExists", (Func<SessionFsSqliteExistsRequest, CancellationToken, ValueTask<SessionFsSqliteExistsResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).SessionFs;
            if (handler is null) throw new InvalidOperationException($"No sessionFs handler registered for session: {request.SessionId}");
            return await handler.SqliteExistsAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("canvas.open", (Func<CanvasProviderOpenRequest, CancellationToken, ValueTask<CanvasProviderOpenResult>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).Canvas;
            if (handler is null) throw new InvalidOperationException($"No canvas handler registered for session: {request.SessionId}");
            return await handler.OpenAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("canvas.close", (Func<CanvasProviderCloseRequest, CancellationToken, ValueTask>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).Canvas;
            if (handler is null) throw new InvalidOperationException($"No canvas handler registered for session: {request.SessionId}");
            await handler.CloseAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("canvas.action.invoke", (Func<CanvasProviderInvokeActionRequest, CancellationToken, ValueTask<object>>)(async (request, cancellationToken) =>
        {
            var handler = getHandlers(request.SessionId).Canvas;
            if (handler is null) throw new InvalidOperationException($"No canvas handler registered for session: {request.SessionId}");
            return await handler.InvokeAsync(request, cancellationToken);
        }), singleObjectParam: true);
    }
}

/// <summary>Handles `extensionLaunchProvider` client global API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface IExtensionLaunchProviderHandler
{
    /// <summary>Asks the registered SDK client to resolve an opaque process launch profile for one discovered extension entrypoint immediately before launch or reload. The provider must respond within 15 seconds.</summary>
    /// <param name="request">A discovered extension entrypoint that the registered integrator may classify and resolve to an opaque launch profile.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>The launch profile for a supported entrypoint. Omit launch when the provider does not support the entrypoint.</returns>
    Task<ExtensionLaunchProviderResolveResult> ResolveAsync(ExtensionLaunchProviderResolveRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Handles `llmInference` client global API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface ILlmInferenceHandler
{
    /// <summary>Announces an outbound model-layer HTTP request the runtime wants the SDK client to service. Carries the request head only; the body always follows as one or more httpRequestChunk frames keyed by the same requestId, even when the body is empty (a single chunk with end=true).</summary>
    /// <param name="request">The head of an outbound model-layer HTTP request.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Acknowledgement. Returning successfully simply means the SDK accepted the start frame; it does not imply the request will succeed.</returns>
    Task<LlmInferenceHttpRequestStartResult> HttpRequestStartAsync(LlmInferenceHttpRequestStartRequest request, CancellationToken cancellationToken = default);
    /// <summary>Delivers a body byte range (or a cancellation signal) for a request previously announced via httpRequestStart, correlated by requestId. The runtime fires at least one chunk per request — when there is no body, a single chunk with empty data and end=true. Mid-stream the runtime may send a chunk with cancel=true to abort the request; the SDK then stops issuing httpResponseChunk frames and may emit a terminal httpResponseChunk with error set.</summary>
    /// <param name="request">A request body chunk or cancellation signal.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>Acknowledgement. The SDK is free to ignore the ack and treat chunk delivery as fire-and-forget.</returns>
    Task<LlmInferenceHttpRequestChunkResult> HttpRequestChunkAsync(LlmInferenceHttpRequestChunkRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Handles `gitHubTelemetry` client global API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface IGitHubTelemetryHandler
{
    /// <summary>Forwards a single GitHub telemetry event to a host connection that opted into telemetry forwarding during the `server.connect` handshake. Opted-in connections receive every event the runtime emits after the handshake — across all sessions, plus sessionless events (for example, `server.sendTelemetry` calls with no session id).</summary>
    /// <param name="request">Payload for a `gitHubTelemetry.event` notification: a single GitHub telemetry event the runtime forwards to a host connection that opted into telemetry forwarding during the `server.connect` handshake.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    Task EventAsync(GitHubTelemetryNotification request, CancellationToken cancellationToken = default);
}

/// <summary>Handles `gitHubToken` client global API methods.</summary>
[Experimental(Diagnostics.Experimental)]
public interface IGitHubTokenHandler
{
    /// <summary>Asks the SDK client to mint a GitHub access token for a session whose configuration supplied a GitHub token provider. The runtime acquires the initial token during bootstrap and refreshes it during expiry preflight when one hour or less remains.</summary>
    /// <param name="request">Asks the SDK client to acquire a GitHub access token from an opaque callback registration.</param>
    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
    /// <returns>SDK host response to a GitHub credential request.</returns>
    Task<GitHubTokenAcquireResult> GetTokenAsync(GitHubTokenAcquireRequest request, CancellationToken cancellationToken = default);
}

/// <summary>Provides all client global API handler groups for a connection.</summary>
public sealed class ClientGlobalApiHandlers
{
    /// <summary>Optional handler for ExtensionLaunchProvider client global API methods.</summary>
    public IExtensionLaunchProviderHandler? ExtensionLaunchProvider { get; set; }

    /// <summary>Optional handler for LlmInference client global API methods.</summary>
    public ILlmInferenceHandler? LlmInference { get; set; }

    /// <summary>Optional handler for GitHubTelemetry client global API methods.</summary>
    public IGitHubTelemetryHandler? GitHubTelemetry { get; set; }

    /// <summary>Optional handler for GitHubToken client global API methods.</summary>
    public IGitHubTokenHandler? GitHubToken { get; set; }
}

/// <summary>Registers client global API handlers on a JSON-RPC connection.</summary>
internal static class ClientGlobalApiRegistration
{
    /// <summary>
    /// Registers handlers for server-to-client global API calls.
    /// Unlike client session APIs, these methods carry no implicit
    /// <c>sessionId</c> dispatch key — a single set of handlers serves the
    /// entire connection.
    /// </summary>
    public static void RegisterClientGlobalApiHandlers(JsonRpc rpc, ClientGlobalApiHandlers handlers)
    {
        rpc.SetLocalRpcMethod("extensionLaunchProvider.resolve", (Func<ExtensionLaunchProviderResolveRequest, CancellationToken, ValueTask<ExtensionLaunchProviderResolveResult>>)(async (request, cancellationToken) =>
        {
            var handler = handlers.ExtensionLaunchProvider ?? throw new InvalidOperationException("No extensionLaunchProvider client-global handler registered");
            return await handler.ResolveAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("llmInference.httpRequestStart", (Func<LlmInferenceHttpRequestStartRequest, CancellationToken, ValueTask<LlmInferenceHttpRequestStartResult>>)(async (request, cancellationToken) =>
        {
            var handler = handlers.LlmInference ?? throw new InvalidOperationException("No llmInference client-global handler registered");
            return await handler.HttpRequestStartAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("llmInference.httpRequestChunk", (Func<LlmInferenceHttpRequestChunkRequest, CancellationToken, ValueTask<LlmInferenceHttpRequestChunkResult>>)(async (request, cancellationToken) =>
        {
            var handler = handlers.LlmInference ?? throw new InvalidOperationException("No llmInference client-global handler registered");
            return await handler.HttpRequestChunkAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("gitHubTelemetry.event", (Func<GitHubTelemetryNotification, CancellationToken, ValueTask>)(async (request, cancellationToken) =>
        {
            var handler = handlers.GitHubTelemetry ?? throw new InvalidOperationException("No gitHubTelemetry client-global handler registered");
            await handler.EventAsync(request, cancellationToken);
        }), singleObjectParam: true);
        rpc.SetLocalRpcMethod("gitHubToken.getToken", (Func<GitHubTokenAcquireRequest, CancellationToken, ValueTask<GitHubTokenAcquireResult>>)(async (request, cancellationToken) =>
        {
            var handler = handlers.GitHubToken ?? throw new InvalidOperationException("No gitHubToken client-global handler registered");
            return await handler.GetTokenAsync(request, cancellationToken);
        }), singleObjectParam: true);
    }
}

[JsonSourceGenerationOptions(
    JsonSerializerDefaults.Web,
    AllowOutOfOrderMetadataProperties = true,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
[JsonSerializable(typeof(bool))]
[JsonSerializable(typeof(double))]
[JsonSerializable(typeof(int))]
[JsonSerializable(typeof(long))]
[JsonSerializable(typeof(string))]
[JsonSerializable(typeof(GitHub.Copilot.AbortData), TypeInfoPropertyName = "SessionEventsAbortData")]
[JsonSerializable(typeof(GitHub.Copilot.AbortEvent), TypeInfoPropertyName = "SessionEventsAbortEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AbortReason), TypeInfoPropertyName = "SessionEventsAbortReason")]
[JsonSerializable(typeof(GitHub.Copilot.AgentInterruptedActivity), TypeInfoPropertyName = "SessionEventsAgentInterruptedActivity")]
[JsonSerializable(typeof(GitHub.Copilot.AgentInterruptedCancelPhase), TypeInfoPropertyName = "SessionEventsAgentInterruptedCancelPhase")]
[JsonSerializable(typeof(GitHub.Copilot.AgentInterruptedData), TypeInfoPropertyName = "SessionEventsAgentInterruptedData")]
[JsonSerializable(typeof(GitHub.Copilot.AgentInterruptedEvent), TypeInfoPropertyName = "SessionEventsAgentInterruptedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AgentModelPolicy), TypeInfoPropertyName = "SessionEventsAgentModelPolicy")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantFusionPhaseActivityEvent), TypeInfoPropertyName = "SessionEventsAssistantFusionPhaseActivityEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantFusionPhaseCompletedEvent), TypeInfoPropertyName = "SessionEventsAssistantFusionPhaseCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantFusionPhaseFailedEvent), TypeInfoPropertyName = "SessionEventsAssistantFusionPhaseFailedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantFusionPhaseStartedEvent), TypeInfoPropertyName = "SessionEventsAssistantFusionPhaseStartedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantIdleData), TypeInfoPropertyName = "SessionEventsAssistantIdleData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantIdleEvent), TypeInfoPropertyName = "SessionEventsAssistantIdleEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantIntentData), TypeInfoPropertyName = "SessionEventsAssistantIntentData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantIntentEvent), TypeInfoPropertyName = "SessionEventsAssistantIntentEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageData), TypeInfoPropertyName = "SessionEventsAssistantMessageData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageDeltaData), TypeInfoPropertyName = "SessionEventsAssistantMessageDeltaData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageDeltaEvent), TypeInfoPropertyName = "SessionEventsAssistantMessageDeltaEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageEvent), TypeInfoPropertyName = "SessionEventsAssistantMessageEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageReasoningBlocks), TypeInfoPropertyName = "SessionEventsAssistantMessageReasoningBlocks")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageServerTools), TypeInfoPropertyName = "SessionEventsAssistantMessageServerTools")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageStartData), TypeInfoPropertyName = "SessionEventsAssistantMessageStartData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageStartEvent), TypeInfoPropertyName = "SessionEventsAssistantMessageStartEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageToolRequest), TypeInfoPropertyName = "SessionEventsAssistantMessageToolRequest")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageToolRequestCaller), TypeInfoPropertyName = "SessionEventsAssistantMessageToolRequestCaller")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageToolRequestCallerType), TypeInfoPropertyName = "SessionEventsAssistantMessageToolRequestCallerType")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantMessageToolRequestType), TypeInfoPropertyName = "SessionEventsAssistantMessageToolRequestType")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantReasoningData), TypeInfoPropertyName = "SessionEventsAssistantReasoningData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantReasoningDeltaData), TypeInfoPropertyName = "SessionEventsAssistantReasoningDeltaData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantReasoningDeltaEvent), TypeInfoPropertyName = "SessionEventsAssistantReasoningDeltaEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantReasoningEvent), TypeInfoPropertyName = "SessionEventsAssistantReasoningEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantServerToolProgressData), TypeInfoPropertyName = "SessionEventsAssistantServerToolProgressData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantServerToolProgressEvent), TypeInfoPropertyName = "SessionEventsAssistantServerToolProgressEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantStreamingDeltaData), TypeInfoPropertyName = "SessionEventsAssistantStreamingDeltaData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantStreamingDeltaEvent), TypeInfoPropertyName = "SessionEventsAssistantStreamingDeltaEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantToolCallDeltaData), TypeInfoPropertyName = "SessionEventsAssistantToolCallDeltaData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantToolCallDeltaEvent), TypeInfoPropertyName = "SessionEventsAssistantToolCallDeltaEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantTurnEndData), TypeInfoPropertyName = "SessionEventsAssistantTurnEndData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantTurnEndEvent), TypeInfoPropertyName = "SessionEventsAssistantTurnEndEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantTurnRetryData), TypeInfoPropertyName = "SessionEventsAssistantTurnRetryData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantTurnRetryEvent), TypeInfoPropertyName = "SessionEventsAssistantTurnRetryEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantTurnStartData), TypeInfoPropertyName = "SessionEventsAssistantTurnStartData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantTurnStartEvent), TypeInfoPropertyName = "SessionEventsAssistantTurnStartEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantUsageApiEndpoint), TypeInfoPropertyName = "SessionEventsAssistantUsageApiEndpoint")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantUsageCopilotUsage), TypeInfoPropertyName = "SessionEventsAssistantUsageCopilotUsage")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantUsageCopilotUsageTokenDetail), TypeInfoPropertyName = "SessionEventsAssistantUsageCopilotUsageTokenDetail")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantUsageData), TypeInfoPropertyName = "SessionEventsAssistantUsageData")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantUsageEvent), TypeInfoPropertyName = "SessionEventsAssistantUsageEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AssistantUsageTransport), TypeInfoPropertyName = "SessionEventsAssistantUsageTransport")]
[JsonSerializable(typeof(GitHub.Copilot.AssistedApprovalJudgeFailureReason), TypeInfoPropertyName = "SessionEventsAssistedApprovalJudgeFailureReason")]
[JsonSerializable(typeof(GitHub.Copilot.AssistedApprovalRecommendation), TypeInfoPropertyName = "SessionEventsAssistedApprovalRecommendation")]
[JsonSerializable(typeof(GitHub.Copilot.Attachment), TypeInfoPropertyName = "SessionEventsAttachment")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentBlob), TypeInfoPropertyName = "SessionEventsAttachmentBlob")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentDirectory), TypeInfoPropertyName = "SessionEventsAttachmentDirectory")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentExtensionContext), TypeInfoPropertyName = "SessionEventsAttachmentExtensionContext")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentFile), TypeInfoPropertyName = "SessionEventsAttachmentFile")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentFileLineRange), TypeInfoPropertyName = "SessionEventsAttachmentFileLineRange")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubActionsJob), TypeInfoPropertyName = "SessionEventsAttachmentGitHubActionsJob")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubCommit), TypeInfoPropertyName = "SessionEventsAttachmentGitHubCommit")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubFile), TypeInfoPropertyName = "SessionEventsAttachmentGitHubFile")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubFileDiff), TypeInfoPropertyName = "SessionEventsAttachmentGitHubFileDiff")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubFileDiffSide), TypeInfoPropertyName = "SessionEventsAttachmentGitHubFileDiffSide")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubReference), TypeInfoPropertyName = "SessionEventsAttachmentGitHubReference")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubReferenceType), TypeInfoPropertyName = "SessionEventsAttachmentGitHubReferenceType")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubRelease), TypeInfoPropertyName = "SessionEventsAttachmentGitHubRelease")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubRepository), TypeInfoPropertyName = "SessionEventsAttachmentGitHubRepository")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubSnippet), TypeInfoPropertyName = "SessionEventsAttachmentGitHubSnippet")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubTreeComparison), TypeInfoPropertyName = "SessionEventsAttachmentGitHubTreeComparison")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubTreeComparisonSide), TypeInfoPropertyName = "SessionEventsAttachmentGitHubTreeComparisonSide")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentGitHubUrl), TypeInfoPropertyName = "SessionEventsAttachmentGitHubUrl")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentSelection), TypeInfoPropertyName = "SessionEventsAttachmentSelection")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentSelectionDetails), TypeInfoPropertyName = "SessionEventsAttachmentSelectionDetails")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentSelectionDetailsEnd), TypeInfoPropertyName = "SessionEventsAttachmentSelectionDetailsEnd")]
[JsonSerializable(typeof(GitHub.Copilot.AttachmentSelectionDetailsStart), TypeInfoPropertyName = "SessionEventsAttachmentSelectionDetailsStart")]
[JsonSerializable(typeof(GitHub.Copilot.AutoModeResolvedReasoningBucket), TypeInfoPropertyName = "SessionEventsAutoModeResolvedReasoningBucket")]
[JsonSerializable(typeof(GitHub.Copilot.AutoModeSwitchCompletedData), TypeInfoPropertyName = "SessionEventsAutoModeSwitchCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.AutoModeSwitchCompletedEvent), TypeInfoPropertyName = "SessionEventsAutoModeSwitchCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AutoModeSwitchRequestedData), TypeInfoPropertyName = "SessionEventsAutoModeSwitchRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.AutoModeSwitchRequestedEvent), TypeInfoPropertyName = "SessionEventsAutoModeSwitchRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.AutoModeSwitchResponse), TypeInfoPropertyName = "SessionEventsAutoModeSwitchResponse")]
[JsonSerializable(typeof(GitHub.Copilot.AutoTier), TypeInfoPropertyName = "SessionEventsAutoTier")]
[JsonSerializable(typeof(GitHub.Copilot.AutoTierSwitchFailureReason), TypeInfoPropertyName = "SessionEventsAutoTierSwitchFailureReason")]
[JsonSerializable(typeof(GitHub.Copilot.AutopilotObjectiveChangedOperation), TypeInfoPropertyName = "SessionEventsAutopilotObjectiveChangedOperation")]
[JsonSerializable(typeof(GitHub.Copilot.AutopilotObjectiveChangedStatus), TypeInfoPropertyName = "SessionEventsAutopilotObjectiveChangedStatus")]
[JsonSerializable(typeof(GitHub.Copilot.BinaryAssetReference), TypeInfoPropertyName = "SessionEventsBinaryAssetReference")]
[JsonSerializable(typeof(GitHub.Copilot.BinaryAssetReferenceType), TypeInfoPropertyName = "SessionEventsBinaryAssetReferenceType")]
[JsonSerializable(typeof(GitHub.Copilot.BinaryAssetType), TypeInfoPropertyName = "SessionEventsBinaryAssetType")]
[JsonSerializable(typeof(GitHub.Copilot.CanvasRegistryChangedCanvas), TypeInfoPropertyName = "SessionEventsCanvasRegistryChangedCanvas")]
[JsonSerializable(typeof(GitHub.Copilot.CanvasRegistryChangedCanvasAction), TypeInfoPropertyName = "SessionEventsCanvasRegistryChangedCanvasAction")]
[JsonSerializable(typeof(GitHub.Copilot.CapabilitiesChangedData), TypeInfoPropertyName = "SessionEventsCapabilitiesChangedData")]
[JsonSerializable(typeof(GitHub.Copilot.CapabilitiesChangedEvent), TypeInfoPropertyName = "SessionEventsCapabilitiesChangedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.CapabilitiesChangedUI), TypeInfoPropertyName = "SessionEventsCapabilitiesChangedUI")]
[JsonSerializable(typeof(GitHub.Copilot.CitableSource), TypeInfoPropertyName = "SessionEventsCitableSource")]
[JsonSerializable(typeof(GitHub.Copilot.CitationLocation), TypeInfoPropertyName = "SessionEventsCitationLocation")]
[JsonSerializable(typeof(GitHub.Copilot.CitationLocationBlock), TypeInfoPropertyName = "SessionEventsCitationLocationBlock")]
[JsonSerializable(typeof(GitHub.Copilot.CitationLocationChar), TypeInfoPropertyName = "SessionEventsCitationLocationChar")]
[JsonSerializable(typeof(GitHub.Copilot.CitationLocationPage), TypeInfoPropertyName = "SessionEventsCitationLocationPage")]
[JsonSerializable(typeof(GitHub.Copilot.CitationProvider), TypeInfoPropertyName = "SessionEventsCitationProvider")]
[JsonSerializable(typeof(GitHub.Copilot.CitationReference), TypeInfoPropertyName = "SessionEventsCitationReference")]
[JsonSerializable(typeof(GitHub.Copilot.CitationSource), TypeInfoPropertyName = "SessionEventsCitationSource")]
[JsonSerializable(typeof(GitHub.Copilot.CitationSpan), TypeInfoPropertyName = "SessionEventsCitationSpan")]
[JsonSerializable(typeof(GitHub.Copilot.Citations), TypeInfoPropertyName = "SessionEventsCitations")]
[JsonSerializable(typeof(GitHub.Copilot.CommandCompletedData), TypeInfoPropertyName = "SessionEventsCommandCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.CommandCompletedEvent), TypeInfoPropertyName = "SessionEventsCommandCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.CommandExecuteData), TypeInfoPropertyName = "SessionEventsCommandExecuteData")]
[JsonSerializable(typeof(GitHub.Copilot.CommandExecuteEvent), TypeInfoPropertyName = "SessionEventsCommandExecuteEvent")]
[JsonSerializable(typeof(GitHub.Copilot.CommandQueuedData), TypeInfoPropertyName = "SessionEventsCommandQueuedData")]
[JsonSerializable(typeof(GitHub.Copilot.CommandQueuedEvent), TypeInfoPropertyName = "SessionEventsCommandQueuedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.CommandsChangedCommand), TypeInfoPropertyName = "SessionEventsCommandsChangedCommand")]
[JsonSerializable(typeof(GitHub.Copilot.CommandsChangedData), TypeInfoPropertyName = "SessionEventsCommandsChangedData")]
[JsonSerializable(typeof(GitHub.Copilot.CommandsChangedEvent), TypeInfoPropertyName = "SessionEventsCommandsChangedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.CompactionCompleteCompactionTokensUsed), TypeInfoPropertyName = "SessionEventsCompactionCompleteCompactionTokensUsed")]
[JsonSerializable(typeof(GitHub.Copilot.CompactionCompleteCompactionTokensUsedCopilotUsageTokenDetail), TypeInfoPropertyName = "SessionEventsCompactionCompleteCompactionTokensUsedCopilotUsageTokenDetail")]
[JsonSerializable(typeof(GitHub.Copilot.CompactionTrigger), TypeInfoPropertyName = "SessionEventsCompactionTrigger")]
[JsonSerializable(typeof(GitHub.Copilot.CompletionReceiptEventRange), TypeInfoPropertyName = "SessionEventsCompletionReceiptEventRange")]
[JsonSerializable(typeof(GitHub.Copilot.CompletionReceiptFinalTool), TypeInfoPropertyName = "SessionEventsCompletionReceiptFinalTool")]
[JsonSerializable(typeof(GitHub.Copilot.CompletionReceiptStopReason), TypeInfoPropertyName = "SessionEventsCompletionReceiptStopReason")]
[JsonSerializable(typeof(GitHub.Copilot.CompletionReceiptToolStatus), TypeInfoPropertyName = "SessionEventsCompletionReceiptToolStatus")]
[JsonSerializable(typeof(GitHub.Copilot.ContextTier), TypeInfoPropertyName = "SessionEventsContextTier")]
[JsonSerializable(typeof(GitHub.Copilot.CustomAgentsUpdatedAgent), TypeInfoPropertyName = "SessionEventsCustomAgentsUpdatedAgent")]
[JsonSerializable(typeof(GitHub.Copilot.ElicitationCompletedAction), TypeInfoPropertyName = "SessionEventsElicitationCompletedAction")]
[JsonSerializable(typeof(GitHub.Copilot.ElicitationCompletedData), TypeInfoPropertyName = "SessionEventsElicitationCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.ElicitationCompletedEvent), TypeInfoPropertyName = "SessionEventsElicitationCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ElicitationRequestedData), TypeInfoPropertyName = "SessionEventsElicitationRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.ElicitationRequestedEvent), TypeInfoPropertyName = "SessionEventsElicitationRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ElicitationRequestedMode), TypeInfoPropertyName = "SessionEventsElicitationRequestedMode")]
[JsonSerializable(typeof(GitHub.Copilot.ElicitationRequestedSchema), TypeInfoPropertyName = "SessionEventsElicitationRequestedSchema")]
[JsonSerializable(typeof(GitHub.Copilot.EmbeddedBlobResourceContents), TypeInfoPropertyName = "SessionEventsEmbeddedBlobResourceContents")]
[JsonSerializable(typeof(GitHub.Copilot.EmbeddedTextResourceContents), TypeInfoPropertyName = "SessionEventsEmbeddedTextResourceContents")]
[JsonSerializable(typeof(GitHub.Copilot.ExitPlanModeAction), TypeInfoPropertyName = "SessionEventsExitPlanModeAction")]
[JsonSerializable(typeof(GitHub.Copilot.ExitPlanModeCompletedData), TypeInfoPropertyName = "SessionEventsExitPlanModeCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.ExitPlanModeCompletedEvent), TypeInfoPropertyName = "SessionEventsExitPlanModeCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ExitPlanModeRequestedData), TypeInfoPropertyName = "SessionEventsExitPlanModeRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.ExitPlanModeRequestedEvent), TypeInfoPropertyName = "SessionEventsExitPlanModeRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ExtensionsLoadedExtension), TypeInfoPropertyName = "SessionEventsExtensionsLoadedExtension")]
[JsonSerializable(typeof(GitHub.Copilot.ExtensionsLoadedExtensionSource), TypeInfoPropertyName = "SessionEventsExtensionsLoadedExtensionSource")]
[JsonSerializable(typeof(GitHub.Copilot.ExtensionsLoadedExtensionStatus), TypeInfoPropertyName = "SessionEventsExtensionsLoadedExtensionStatus")]
[JsonSerializable(typeof(GitHub.Copilot.ExternalToolCompletedData), TypeInfoPropertyName = "SessionEventsExternalToolCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.ExternalToolCompletedEvent), TypeInfoPropertyName = "SessionEventsExternalToolCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ExternalToolRequestedData), TypeInfoPropertyName = "SessionEventsExternalToolRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.ExternalToolRequestedEvent), TypeInfoPropertyName = "SessionEventsExternalToolRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryPermissionOperation), TypeInfoPropertyName = "SessionEventsFactoryPermissionOperation")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryPermissionPhase), TypeInfoPropertyName = "SessionEventsFactoryPermissionPhase")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryRunSettledData), TypeInfoPropertyName = "SessionEventsFactoryRunSettledData")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryRunSettledEvent), TypeInfoPropertyName = "SessionEventsFactoryRunSettledEvent")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryRunSettledStatus), TypeInfoPropertyName = "SessionEventsFactoryRunSettledStatus")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryRunStartedData), TypeInfoPropertyName = "SessionEventsFactoryRunStartedData")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryRunStartedEvent), TypeInfoPropertyName = "SessionEventsFactoryRunStartedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryRunUpdatedData), TypeInfoPropertyName = "SessionEventsFactoryRunUpdatedData")]
[JsonSerializable(typeof(GitHub.Copilot.FactoryRunUpdatedEvent), TypeInfoPropertyName = "SessionEventsFactoryRunUpdatedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.FusionAttribution), TypeInfoPropertyName = "SessionEventsFusionAttribution")]
[JsonSerializable(typeof(GitHub.Copilot.FusionConversationScope), TypeInfoPropertyName = "SessionEventsFusionConversationScope")]
[JsonSerializable(typeof(GitHub.Copilot.FusionFollowUpAction), TypeInfoPropertyName = "SessionEventsFusionFollowUpAction")]
[JsonSerializable(typeof(GitHub.Copilot.FusionFollowUpRecommendation), TypeInfoPropertyName = "SessionEventsFusionFollowUpRecommendation")]
[JsonSerializable(typeof(GitHub.Copilot.FusionPattern), TypeInfoPropertyName = "SessionEventsFusionPattern")]
[JsonSerializable(typeof(GitHub.Copilot.FusionPhaseActivityKind), TypeInfoPropertyName = "SessionEventsFusionPhaseActivityKind")]
[JsonSerializable(typeof(GitHub.Copilot.FusionPhaseKind), TypeInfoPropertyName = "SessionEventsFusionPhaseKind")]
[JsonSerializable(typeof(GitHub.Copilot.FusionPhasePlanStep), TypeInfoPropertyName = "SessionEventsFusionPhasePlanStep")]
[JsonSerializable(typeof(GitHub.Copilot.FusionPhaseStatus), TypeInfoPropertyName = "SessionEventsFusionPhaseStatus")]
[JsonSerializable(typeof(GitHub.Copilot.FusionPhaseUsage), TypeInfoPropertyName = "SessionEventsFusionPhaseUsage")]
[JsonSerializable(typeof(GitHub.Copilot.FusionProjectionMode), TypeInfoPropertyName = "SessionEventsFusionProjectionMode")]
[JsonSerializable(typeof(GitHub.Copilot.FusionScores), TypeInfoPropertyName = "SessionEventsFusionScores")]
[JsonSerializable(typeof(GitHub.Copilot.FusionTurnKind), TypeInfoPropertyName = "SessionEventsFusionTurnKind")]
[JsonSerializable(typeof(GitHub.Copilot.GitHubMcpToolConfig), TypeInfoPropertyName = "SessionEventsGitHubMcpToolConfig")]
[JsonSerializable(typeof(GitHub.Copilot.GitHubRepoRef), TypeInfoPropertyName = "SessionEventsGitHubRepoRef")]
[JsonSerializable(typeof(GitHub.Copilot.HandoffRepository), TypeInfoPropertyName = "SessionEventsHandoffRepository")]
[JsonSerializable(typeof(GitHub.Copilot.HandoffSourceType), TypeInfoPropertyName = "SessionEventsHandoffSourceType")]
[JsonSerializable(typeof(GitHub.Copilot.HeaderEntry), TypeInfoPropertyName = "SessionEventsHeaderEntry")]
[JsonSerializable(typeof(GitHub.Copilot.HookEndData), TypeInfoPropertyName = "SessionEventsHookEndData")]
[JsonSerializable(typeof(GitHub.Copilot.HookEndError), TypeInfoPropertyName = "SessionEventsHookEndError")]
[JsonSerializable(typeof(GitHub.Copilot.HookEndEvent), TypeInfoPropertyName = "SessionEventsHookEndEvent")]
[JsonSerializable(typeof(GitHub.Copilot.HookProgressData), TypeInfoPropertyName = "SessionEventsHookProgressData")]
[JsonSerializable(typeof(GitHub.Copilot.HookProgressEvent), TypeInfoPropertyName = "SessionEventsHookProgressEvent")]
[JsonSerializable(typeof(GitHub.Copilot.HookStartData), TypeInfoPropertyName = "SessionEventsHookStartData")]
[JsonSerializable(typeof(GitHub.Copilot.HookStartEvent), TypeInfoPropertyName = "SessionEventsHookStartEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ManagedSettingsEnforcedAction), TypeInfoPropertyName = "SessionEventsManagedSettingsEnforcedAction")]
[JsonSerializable(typeof(GitHub.Copilot.ManagedSettingsEnforcedEscalation), TypeInfoPropertyName = "SessionEventsManagedSettingsEnforcedEscalation")]
[JsonSerializable(typeof(GitHub.Copilot.ManagedSettingsResolvedSource), TypeInfoPropertyName = "SessionEventsManagedSettingsResolvedSource")]
[JsonSerializable(typeof(GitHub.Copilot.McpAppToolCallCompleteData), TypeInfoPropertyName = "SessionEventsMcpAppToolCallCompleteData")]
[JsonSerializable(typeof(GitHub.Copilot.McpAppToolCallCompleteError), TypeInfoPropertyName = "SessionEventsMcpAppToolCallCompleteError")]
[JsonSerializable(typeof(GitHub.Copilot.McpAppToolCallCompleteEvent), TypeInfoPropertyName = "SessionEventsMcpAppToolCallCompleteEvent")]
[JsonSerializable(typeof(GitHub.Copilot.McpAppToolCallCompleteToolMeta), TypeInfoPropertyName = "SessionEventsMcpAppToolCallCompleteToolMeta")]
[JsonSerializable(typeof(GitHub.Copilot.McpAppToolCallCompleteToolMetaUI), TypeInfoPropertyName = "SessionEventsMcpAppToolCallCompleteToolMetaUI")]
[JsonSerializable(typeof(GitHub.Copilot.McpHeadersRefreshCompletedData), TypeInfoPropertyName = "SessionEventsMcpHeadersRefreshCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.McpHeadersRefreshCompletedEvent), TypeInfoPropertyName = "SessionEventsMcpHeadersRefreshCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.McpHeadersRefreshCompletedOutcome), TypeInfoPropertyName = "SessionEventsMcpHeadersRefreshCompletedOutcome")]
[JsonSerializable(typeof(GitHub.Copilot.McpHeadersRefreshRequiredData), TypeInfoPropertyName = "SessionEventsMcpHeadersRefreshRequiredData")]
[JsonSerializable(typeof(GitHub.Copilot.McpHeadersRefreshRequiredEvent), TypeInfoPropertyName = "SessionEventsMcpHeadersRefreshRequiredEvent")]
[JsonSerializable(typeof(GitHub.Copilot.McpHeadersRefreshRequiredReason), TypeInfoPropertyName = "SessionEventsMcpHeadersRefreshRequiredReason")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthCompletedData), TypeInfoPropertyName = "SessionEventsMcpOauthCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthCompletedEvent), TypeInfoPropertyName = "SessionEventsMcpOauthCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthCompletionOutcome), TypeInfoPropertyName = "SessionEventsMcpOauthCompletionOutcome")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthHttpResponse), TypeInfoPropertyName = "SessionEventsMcpOauthHttpResponse")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthRequestReason), TypeInfoPropertyName = "SessionEventsMcpOauthRequestReason")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthRequiredData), TypeInfoPropertyName = "SessionEventsMcpOauthRequiredData")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthRequiredEvent), TypeInfoPropertyName = "SessionEventsMcpOauthRequiredEvent")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthRequiredStaticClientConfig), TypeInfoPropertyName = "SessionEventsMcpOauthRequiredStaticClientConfig")]
[JsonSerializable(typeof(GitHub.Copilot.McpOauthWWWAuthenticateParams), TypeInfoPropertyName = "SessionEventsMcpOauthWWWAuthenticateParams")]
[JsonSerializable(typeof(GitHub.Copilot.McpPromptsListChangedEvent), TypeInfoPropertyName = "SessionEventsMcpPromptsListChangedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.McpResourcesListChangedEvent), TypeInfoPropertyName = "SessionEventsMcpResourcesListChangedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.McpServerMetadata), TypeInfoPropertyName = "SessionEventsMcpServerMetadata")]
[JsonSerializable(typeof(GitHub.Copilot.McpServerSource), TypeInfoPropertyName = "SessionEventsMcpServerSource")]
[JsonSerializable(typeof(GitHub.Copilot.McpServerStatus), TypeInfoPropertyName = "SessionEventsMcpServerStatus")]
[JsonSerializable(typeof(GitHub.Copilot.McpServerTransport), TypeInfoPropertyName = "SessionEventsMcpServerTransport")]
[JsonSerializable(typeof(GitHub.Copilot.McpServersLoadedServer), TypeInfoPropertyName = "SessionEventsMcpServersLoadedServer")]
[JsonSerializable(typeof(GitHub.Copilot.McpToolsListChangedEvent), TypeInfoPropertyName = "SessionEventsMcpToolsListChangedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFailureBadRequestKind), TypeInfoPropertyName = "SessionEventsModelCallFailureBadRequestKind")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFailureData), TypeInfoPropertyName = "SessionEventsModelCallFailureData")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFailureEvent), TypeInfoPropertyName = "SessionEventsModelCallFailureEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFailureKind), TypeInfoPropertyName = "SessionEventsModelCallFailureKind")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFailureRequestFingerprint), TypeInfoPropertyName = "SessionEventsModelCallFailureRequestFingerprint")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFailureSource), TypeInfoPropertyName = "SessionEventsModelCallFailureSource")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFailureTransport), TypeInfoPropertyName = "SessionEventsModelCallFailureTransport")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFinishedData), TypeInfoPropertyName = "SessionEventsModelCallFinishedData")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFinishedEvent), TypeInfoPropertyName = "SessionEventsModelCallFinishedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallFinishedOutcome), TypeInfoPropertyName = "SessionEventsModelCallFinishedOutcome")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallStartData), TypeInfoPropertyName = "SessionEventsModelCallStartData")]
[JsonSerializable(typeof(GitHub.Copilot.ModelCallStartEvent), TypeInfoPropertyName = "SessionEventsModelCallStartEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ModelChangeSource), TypeInfoPropertyName = "SessionEventsModelChangeSource")]
[JsonSerializable(typeof(GitHub.Copilot.OmittedBinaryOmittedReason), TypeInfoPropertyName = "SessionEventsOmittedBinaryOmittedReason")]
[JsonSerializable(typeof(GitHub.Copilot.OmittedBinaryResult), TypeInfoPropertyName = "SessionEventsOmittedBinaryResult")]
[JsonSerializable(typeof(GitHub.Copilot.OmittedBinaryType), TypeInfoPropertyName = "SessionEventsOmittedBinaryType")]
[JsonSerializable(typeof(GitHub.Copilot.PendingMessagesModifiedData), TypeInfoPropertyName = "SessionEventsPendingMessagesModifiedData")]
[JsonSerializable(typeof(GitHub.Copilot.PendingMessagesModifiedEvent), TypeInfoPropertyName = "SessionEventsPendingMessagesModifiedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionAssistedApproval), TypeInfoPropertyName = "SessionEventsPermissionAssistedApproval")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionCompletedData), TypeInfoPropertyName = "SessionEventsPermissionCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionCompletedEvent), TypeInfoPropertyName = "SessionEventsPermissionCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionMode), TypeInfoPropertyName = "SessionEventsPermissionMode")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequest), TypeInfoPropertyName = "SessionEventsPermissionPromptRequest")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestCommands), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestCommands")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestCustomTool), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestCustomTool")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestExtensionEnvAccess), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestExtensionEnvAccess")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestExtensionManagement), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestExtensionManagement")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestExtensionPermissionAccess), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestExtensionPermissionAccess")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestFactory), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestFactory")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestHook), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestHook")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestMcp), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestMcp")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestMemory), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestMemory")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestPath), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestPath")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestPathAccessKind), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestPathAccessKind")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestRead), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestRead")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestUrl), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestUrl")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionPromptRequestWrite), TypeInfoPropertyName = "SessionEventsPermissionPromptRequestWrite")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRecommendation), TypeInfoPropertyName = "SessionEventsPermissionRecommendation")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequest), TypeInfoPropertyName = "SessionEventsPermissionRequest")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestCustomTool), TypeInfoPropertyName = "SessionEventsPermissionRequestCustomTool")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestExtensionEnvAccess), TypeInfoPropertyName = "SessionEventsPermissionRequestExtensionEnvAccess")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestExtensionManagement), TypeInfoPropertyName = "SessionEventsPermissionRequestExtensionManagement")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestExtensionPermissionAccess), TypeInfoPropertyName = "SessionEventsPermissionRequestExtensionPermissionAccess")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestFactory), TypeInfoPropertyName = "SessionEventsPermissionRequestFactory")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestHook), TypeInfoPropertyName = "SessionEventsPermissionRequestHook")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestMcp), TypeInfoPropertyName = "SessionEventsPermissionRequestMcp")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestMemory), TypeInfoPropertyName = "SessionEventsPermissionRequestMemory")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestMemoryAction), TypeInfoPropertyName = "SessionEventsPermissionRequestMemoryAction")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestMemoryDirection), TypeInfoPropertyName = "SessionEventsPermissionRequestMemoryDirection")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestMemoryScope), TypeInfoPropertyName = "SessionEventsPermissionRequestMemoryScope")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestRead), TypeInfoPropertyName = "SessionEventsPermissionRequestRead")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestShell), TypeInfoPropertyName = "SessionEventsPermissionRequestShell")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestShellCommand), TypeInfoPropertyName = "SessionEventsPermissionRequestShellCommand")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestShellCommandSegment), TypeInfoPropertyName = "SessionEventsPermissionRequestShellCommandSegment")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestShellPossibleUrl), TypeInfoPropertyName = "SessionEventsPermissionRequestShellPossibleUrl")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestUrl), TypeInfoPropertyName = "SessionEventsPermissionRequestUrl")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestWrite), TypeInfoPropertyName = "SessionEventsPermissionRequestWrite")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestedData), TypeInfoPropertyName = "SessionEventsPermissionRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRequestedEvent), TypeInfoPropertyName = "SessionEventsPermissionRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionResult), TypeInfoPropertyName = "SessionEventsPermissionResult")]
[JsonSerializable(typeof(GitHub.Copilot.PermissionRule), TypeInfoPropertyName = "SessionEventsPermissionRule")]
[JsonSerializable(typeof(GitHub.Copilot.PersistedBinaryImage), TypeInfoPropertyName = "SessionEventsPersistedBinaryImage")]
[JsonSerializable(typeof(GitHub.Copilot.PersistedBinaryImageType), TypeInfoPropertyName = "SessionEventsPersistedBinaryImageType")]
[JsonSerializable(typeof(GitHub.Copilot.PersistedBinaryResult), TypeInfoPropertyName = "SessionEventsPersistedBinaryResult")]
[JsonSerializable(typeof(GitHub.Copilot.PlanChangedOperation), TypeInfoPropertyName = "SessionEventsPlanChangedOperation")]
[JsonSerializable(typeof(GitHub.Copilot.PromptCacheBreakData), TypeInfoPropertyName = "SessionEventsPromptCacheBreakData")]
[JsonSerializable(typeof(GitHub.Copilot.PromptCacheBreakEvent), TypeInfoPropertyName = "SessionEventsPromptCacheBreakEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ReasoningSummary), TypeInfoPropertyName = "SessionEventsReasoningSummary")]
[JsonSerializable(typeof(GitHub.Copilot.RecommendedAutoTier), TypeInfoPropertyName = "SessionEventsRecommendedAutoTier")]
[JsonSerializable(typeof(GitHub.Copilot.RemediationAction), TypeInfoPropertyName = "SessionEventsRemediationAction")]
[JsonSerializable(typeof(GitHub.Copilot.SamplingCompletedData), TypeInfoPropertyName = "SessionEventsSamplingCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.SamplingCompletedEvent), TypeInfoPropertyName = "SessionEventsSamplingCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SamplingRequestedData), TypeInfoPropertyName = "SessionEventsSamplingRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.SamplingRequestedEvent), TypeInfoPropertyName = "SessionEventsSamplingRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SandboxDecisionData), TypeInfoPropertyName = "SessionEventsSandboxDecisionData")]
[JsonSerializable(typeof(GitHub.Copilot.SandboxDecisionEvent), TypeInfoPropertyName = "SessionEventsSandboxDecisionEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ScheduleOrigin), TypeInfoPropertyName = "SessionEventsScheduleOrigin")]
[JsonSerializable(typeof(GitHub.Copilot.SessionEvent), TypeInfoPropertyName = "SessionEventsSessionEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SessionLimitsConfig), TypeInfoPropertyName = "SessionEventsSessionLimitsConfig")]
[JsonSerializable(typeof(GitHub.Copilot.SessionLimitsExhaustedCompletedData), TypeInfoPropertyName = "SessionEventsSessionLimitsExhaustedCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.SessionLimitsExhaustedCompletedEvent), TypeInfoPropertyName = "SessionEventsSessionLimitsExhaustedCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SessionLimitsExhaustedRequestedData), TypeInfoPropertyName = "SessionEventsSessionLimitsExhaustedRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.SessionLimitsExhaustedRequestedEvent), TypeInfoPropertyName = "SessionEventsSessionLimitsExhaustedRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SessionLimitsExhaustedResponse), TypeInfoPropertyName = "SessionEventsSessionLimitsExhaustedResponse")]
[JsonSerializable(typeof(GitHub.Copilot.SessionLimitsExhaustedResponseAction), TypeInfoPropertyName = "SessionEventsSessionLimitsExhaustedResponseAction")]
[JsonSerializable(typeof(GitHub.Copilot.SessionMode), TypeInfoPropertyName = "SessionEventsSessionMode")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownAgentMetric), TypeInfoPropertyName = "SessionEventsShutdownAgentMetric")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownCodeChanges), TypeInfoPropertyName = "SessionEventsShutdownCodeChanges")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownModelMetric), TypeInfoPropertyName = "SessionEventsShutdownModelMetric")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownModelMetricRequests), TypeInfoPropertyName = "SessionEventsShutdownModelMetricRequests")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownModelMetricTokenDetail), TypeInfoPropertyName = "SessionEventsShutdownModelMetricTokenDetail")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownModelMetricUsage), TypeInfoPropertyName = "SessionEventsShutdownModelMetricUsage")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownTokenDetail), TypeInfoPropertyName = "SessionEventsShutdownTokenDetail")]
[JsonSerializable(typeof(GitHub.Copilot.ShutdownType), TypeInfoPropertyName = "SessionEventsShutdownType")]
[JsonSerializable(typeof(GitHub.Copilot.SkillInvokedData), TypeInfoPropertyName = "SessionEventsSkillInvokedData")]
[JsonSerializable(typeof(GitHub.Copilot.SkillInvokedEvent), TypeInfoPropertyName = "SessionEventsSkillInvokedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SkillInvokedTrigger), TypeInfoPropertyName = "SessionEventsSkillInvokedTrigger")]
[JsonSerializable(typeof(GitHub.Copilot.SkillSource), TypeInfoPropertyName = "SessionEventsSkillSource")]
[JsonSerializable(typeof(GitHub.Copilot.SkillsLoadedSkill), TypeInfoPropertyName = "SessionEventsSkillsLoadedSkill")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentCompletedData), TypeInfoPropertyName = "SessionEventsSubagentCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentCompletedEvent), TypeInfoPropertyName = "SessionEventsSubagentCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentConfiguredData), TypeInfoPropertyName = "SessionEventsSubagentConfiguredData")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentConfiguredEvent), TypeInfoPropertyName = "SessionEventsSubagentConfiguredEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentDeselectedData), TypeInfoPropertyName = "SessionEventsSubagentDeselectedData")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentDeselectedEvent), TypeInfoPropertyName = "SessionEventsSubagentDeselectedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentFailedData), TypeInfoPropertyName = "SessionEventsSubagentFailedData")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentFailedEvent), TypeInfoPropertyName = "SessionEventsSubagentFailedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentModelSelectionSource), TypeInfoPropertyName = "SessionEventsSubagentModelSelectionSource")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentSelectedData), TypeInfoPropertyName = "SessionEventsSubagentSelectedData")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentSelectedEvent), TypeInfoPropertyName = "SessionEventsSubagentSelectedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentStartedData), TypeInfoPropertyName = "SessionEventsSubagentStartedData")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentStartedEvent), TypeInfoPropertyName = "SessionEventsSubagentStartedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SubagentTaskModelSource), TypeInfoPropertyName = "SessionEventsSubagentTaskModelSource")]
[JsonSerializable(typeof(GitHub.Copilot.SystemMessageData), TypeInfoPropertyName = "SessionEventsSystemMessageData")]
[JsonSerializable(typeof(GitHub.Copilot.SystemMessageEvent), TypeInfoPropertyName = "SessionEventsSystemMessageEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SystemMessageMetadata), TypeInfoPropertyName = "SessionEventsSystemMessageMetadata")]
[JsonSerializable(typeof(GitHub.Copilot.SystemMessageRole), TypeInfoPropertyName = "SessionEventsSystemMessageRole")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotification), TypeInfoPropertyName = "SessionEventsSystemNotification")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationAgentCompleted), TypeInfoPropertyName = "SessionEventsSystemNotificationAgentCompleted")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationAgentCompletedStatus), TypeInfoPropertyName = "SessionEventsSystemNotificationAgentCompletedStatus")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationAgentIdle), TypeInfoPropertyName = "SessionEventsSystemNotificationAgentIdle")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationData), TypeInfoPropertyName = "SessionEventsSystemNotificationData")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationEvent), TypeInfoPropertyName = "SessionEventsSystemNotificationEvent")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationFactoryCompleted), TypeInfoPropertyName = "SessionEventsSystemNotificationFactoryCompleted")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationFactoryCompletedStatus), TypeInfoPropertyName = "SessionEventsSystemNotificationFactoryCompletedStatus")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationFactoryPauseInfo), TypeInfoPropertyName = "SessionEventsSystemNotificationFactoryPauseInfo")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationInstructionDiscovered), TypeInfoPropertyName = "SessionEventsSystemNotificationInstructionDiscovered")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationNewInboxMessage), TypeInfoPropertyName = "SessionEventsSystemNotificationNewInboxMessage")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationShellCompleted), TypeInfoPropertyName = "SessionEventsSystemNotificationShellCompleted")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationShellDetachedCompleted), TypeInfoPropertyName = "SessionEventsSystemNotificationShellDetachedCompleted")]
[JsonSerializable(typeof(GitHub.Copilot.SystemNotificationUnclassified), TypeInfoPropertyName = "SessionEventsSystemNotificationUnclassified")]
[JsonSerializable(typeof(GitHub.Copilot.TaskCompletionOutcome), TypeInfoPropertyName = "SessionEventsTaskCompletionOutcome")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContent), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContent")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentAudio), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentAudio")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentImage), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentImage")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentResource), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentResource")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentResourceDetails), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentResourceDetails")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentResourceLink), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentResourceLink")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentResourceLinkIcon), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentResourceLinkIcon")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentResourceLinkIconTheme), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentResourceLinkIconTheme")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentShellExit), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentShellExit")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentTerminal), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentTerminal")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteContentText), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteContentText")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteData), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteData")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteError), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteError")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteEvent), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteResult), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteResult")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteToolDescription), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteToolDescription")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteToolDescriptionMeta), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteToolDescriptionMeta")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteToolDescriptionMetaUI), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteToolDescriptionMetaUI")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteToolDescriptionMetaUIVisibility), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteToolDescriptionMetaUIVisibility")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResource), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResource")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMeta), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMeta")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMetaUI), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMetaUI")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMetaUICsp), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMetaUICsp")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMetaUIPermissions), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMetaUIPermissions")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMetaUIPermissionsCamera), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMetaUIPermissionsCamera")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMetaUIPermissionsClipboardWrite), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMetaUIPermissionsClipboardWrite")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMetaUIPermissionsGeolocation), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMetaUIPermissionsGeolocation")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionCompleteUIResourceMetaUIPermissionsMicrophone), TypeInfoPropertyName = "SessionEventsToolExecutionCompleteUIResourceMetaUIPermissionsMicrophone")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionPartialResultEvent), TypeInfoPropertyName = "SessionEventsToolExecutionPartialResultEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionProgressData), TypeInfoPropertyName = "SessionEventsToolExecutionProgressData")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionProgressEvent), TypeInfoPropertyName = "SessionEventsToolExecutionProgressEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionStartData), TypeInfoPropertyName = "SessionEventsToolExecutionStartData")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionStartEvent), TypeInfoPropertyName = "SessionEventsToolExecutionStartEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionStartShellToolInfo), TypeInfoPropertyName = "SessionEventsToolExecutionStartShellToolInfo")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionStartToolDescription), TypeInfoPropertyName = "SessionEventsToolExecutionStartToolDescription")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionStartToolDescriptionMeta), TypeInfoPropertyName = "SessionEventsToolExecutionStartToolDescriptionMeta")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionStartToolDescriptionMetaUI), TypeInfoPropertyName = "SessionEventsToolExecutionStartToolDescriptionMetaUI")]
[JsonSerializable(typeof(GitHub.Copilot.ToolExecutionStartToolDescriptionMetaUIVisibility), TypeInfoPropertyName = "SessionEventsToolExecutionStartToolDescriptionMetaUIVisibility")]
[JsonSerializable(typeof(GitHub.Copilot.ToolSearchActivatedData), TypeInfoPropertyName = "SessionEventsToolSearchActivatedData")]
[JsonSerializable(typeof(GitHub.Copilot.ToolSearchActivatedEvent), TypeInfoPropertyName = "SessionEventsToolSearchActivatedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.ToolUserRequestedData), TypeInfoPropertyName = "SessionEventsToolUserRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.ToolUserRequestedEvent), TypeInfoPropertyName = "SessionEventsToolUserRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.UIEphemeralQueryPhase), TypeInfoPropertyName = "SessionEventsUIEphemeralQueryPhase")]
[JsonSerializable(typeof(GitHub.Copilot.UserInputCompletedData), TypeInfoPropertyName = "SessionEventsUserInputCompletedData")]
[JsonSerializable(typeof(GitHub.Copilot.UserInputCompletedEvent), TypeInfoPropertyName = "SessionEventsUserInputCompletedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.UserInputRequestedData), TypeInfoPropertyName = "SessionEventsUserInputRequestedData")]
[JsonSerializable(typeof(GitHub.Copilot.UserInputRequestedEvent), TypeInfoPropertyName = "SessionEventsUserInputRequestedEvent")]
[JsonSerializable(typeof(GitHub.Copilot.UserMessageAgentMode), TypeInfoPropertyName = "SessionEventsUserMessageAgentMode")]
[JsonSerializable(typeof(GitHub.Copilot.UserMessageData), TypeInfoPropertyName = "SessionEventsUserMessageData")]
[JsonSerializable(typeof(GitHub.Copilot.UserMessageDelivery), TypeInfoPropertyName = "SessionEventsUserMessageDelivery")]
[JsonSerializable(typeof(GitHub.Copilot.UserMessageEvent), TypeInfoPropertyName = "SessionEventsUserMessageEvent")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApproval), TypeInfoPropertyName = "SessionEventsUserToolSessionApproval")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalCommands), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalCommands")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalCustomTool), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalCustomTool")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalExtensionEnvAccess), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalExtensionEnvAccess")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalExtensionManagement), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalExtensionManagement")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalExtensionPermissionAccess), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalExtensionPermissionAccess")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalFactory), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalFactory")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalMcp), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalMcp")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalMemory), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalMemory")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalRead), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalRead")]
[JsonSerializable(typeof(GitHub.Copilot.UserToolSessionApprovalWrite), TypeInfoPropertyName = "SessionEventsUserToolSessionApprovalWrite")]
[JsonSerializable(typeof(GitHub.Copilot.Verbosity), TypeInfoPropertyName = "SessionEventsVerbosity")]
[JsonSerializable(typeof(GitHub.Copilot.WorkingDirectoryContext), TypeInfoPropertyName = "SessionEventsWorkingDirectoryContext")]
[JsonSerializable(typeof(GitHub.Copilot.WorkingDirectoryContextHostType), TypeInfoPropertyName = "SessionEventsWorkingDirectoryContextHostType")]
[JsonSerializable(typeof(GitHub.Copilot.WorkspaceFileChangedOperation), TypeInfoPropertyName = "SessionEventsWorkspaceFileChangedOperation")]
[JsonSerializable(typeof(AbortRequest))]
[JsonSerializable(typeof(AbortResult))]
[JsonSerializable(typeof(AccountAllUsers))]
[JsonSerializable(typeof(AccountGetCurrentAuthResult))]
[JsonSerializable(typeof(AccountGetQuotaRequest))]
[JsonSerializable(typeof(AccountGetQuotaResult))]
[JsonSerializable(typeof(AccountLoginRequest))]
[JsonSerializable(typeof(AccountLoginResult))]
[JsonSerializable(typeof(AccountLogoutRequest))]
[JsonSerializable(typeof(AccountLogoutResult))]
[JsonSerializable(typeof(AccountQuotaSnapshot))]
[JsonSerializable(typeof(AgentDiscoveryPath))]
[JsonSerializable(typeof(AgentDiscoveryPathList))]
[JsonSerializable(typeof(AgentGetCurrentResult))]
[JsonSerializable(typeof(AgentInfo))]
[JsonSerializable(typeof(AgentList))]
[JsonSerializable(typeof(AgentRegistryLiveTargetEntry))]
[JsonSerializable(typeof(AgentRegistryLogCapture))]
[JsonSerializable(typeof(AgentRegistrySpawnRequest))]
[JsonSerializable(typeof(AgentRegistrySpawnResult))]
[JsonSerializable(typeof(AgentReloadResult))]
[JsonSerializable(typeof(AgentSelectRequest))]
[JsonSerializable(typeof(AgentSelectResult))]
[JsonSerializable(typeof(AgentSetPromptRequest))]
[JsonSerializable(typeof(AgentsDiscoverRequest))]
[JsonSerializable(typeof(AgentsGetDiscoveryPathsRequest))]
[JsonSerializable(typeof(AuthIdentity))]
[JsonSerializable(typeof(AuthInfo))]
[JsonSerializable(typeof(AuthValidationError))]
[JsonSerializable(typeof(AutopilotObjectiveCreditLimit))]
[JsonSerializable(typeof(AutopilotObjectiveGetStateResult))]
[JsonSerializable(typeof(AutopilotObjectiveState))]
[JsonSerializable(typeof(BuiltInModelCatalog))]
[JsonSerializable(typeof(BuiltInModelCatalogEntry))]
[JsonSerializable(typeof(BuiltinToolDescriptor))]
[JsonSerializable(typeof(BuiltinToolFormat))]
[JsonSerializable(typeof(BuiltinToolInputSchema))]
[JsonSerializable(typeof(CancelUserRequestedShellCommandResult))]
[JsonSerializable(typeof(CanvasAction))]
[JsonSerializable(typeof(CanvasActionInvokeRequest))]
[JsonSerializable(typeof(CanvasActionInvokeResult))]
[JsonSerializable(typeof(CanvasCloseRequest))]
[JsonSerializable(typeof(CanvasHostContext))]
[JsonSerializable(typeof(CanvasHostContextCapabilities))]
[JsonSerializable(typeof(CanvasList))]
[JsonSerializable(typeof(CanvasListOpenResult))]
[JsonSerializable(typeof(CanvasOpenRequest))]
[JsonSerializable(typeof(CanvasProviderCloseRequest))]
[JsonSerializable(typeof(CanvasProviderInvokeActionRequest))]
[JsonSerializable(typeof(CanvasProviderOpenRequest))]
[JsonSerializable(typeof(CanvasProviderOpenResult))]
[JsonSerializable(typeof(CanvasProviderRegisterRequest))]
[JsonSerializable(typeof(CanvasProviderUnregisterRequest))]
[JsonSerializable(typeof(CanvasSessionContext))]
[JsonSerializable(typeof(CapiSessionOptions))]
[JsonSerializable(typeof(CardDigest))]
[JsonSerializable(typeof(CatalogAiSkillCandidateProvenance))]
[JsonSerializable(typeof(CatalogCandidate))]
[JsonSerializable(typeof(CatalogCandidateSource))]
[JsonSerializable(typeof(CatalogClientContract))]
[JsonSerializable(typeof(CatalogMcpServerCandidateProvenance))]
[JsonSerializable(typeof(CatalogNegotiatedContract))]
[JsonSerializable(typeof(CatalogSearchRequest))]
[JsonSerializable(typeof(CatalogSearchResult))]
[JsonSerializable(typeof(ClientTaskCancelRequest))]
[JsonSerializable(typeof(ClientTaskCancelResult))]
[JsonSerializable(typeof(CommandList))]
[JsonSerializable(typeof(CommandsFinalizeInvocationEffectRequest))]
[JsonSerializable(typeof(CommandsFinalizeInvocationEffectRequestEffect))]
[JsonSerializable(typeof(CommandsFinalizeInvocationEffectResult))]
[JsonSerializable(typeof(CommandsHandlePendingCommandRequest))]
[JsonSerializable(typeof(CommandsHandlePendingCommandResult))]
[JsonSerializable(typeof(CommandsInvokeRequest))]
[JsonSerializable(typeof(CommandsRespondToQueuedCommandRequest))]
[JsonSerializable(typeof(CommandsRespondToQueuedCommandResult))]
[JsonSerializable(typeof(CompletionsGetTriggerCharactersResult))]
[JsonSerializable(typeof(CompletionsRequestRequest))]
[JsonSerializable(typeof(CompletionsRequestResult))]
[JsonSerializable(typeof(ConfigureSessionExtensionsParams))]
[JsonSerializable(typeof(ConnectClientInfo))]
[JsonSerializable(typeof(ConnectRemoteSessionParams))]
[JsonSerializable(typeof(ConnectRequest))]
[JsonSerializable(typeof(ConnectResult))]
[JsonSerializable(typeof(ConnectedRemoteSessionMetadata))]
[JsonSerializable(typeof(ConnectedRemoteSessionMetadataRepository))]
[JsonSerializable(typeof(ContentExclusionCheckPathsRequest))]
[JsonSerializable(typeof(ContentExclusionCheckPathsResult))]
[JsonSerializable(typeof(ContentExclusionPathCheck))]
[JsonSerializable(typeof(ContextHeaviestMessage))]
[JsonSerializable(typeof(CopilotUserResponse))]
[JsonSerializable(typeof(CopilotUserResponseEndpoints))]
[JsonSerializable(typeof(CopilotUserResponseOrganizationListItem))]
[JsonSerializable(typeof(CopilotUserResponseQuotaSnapshots))]
[JsonSerializable(typeof(CopilotUserResponseQuotaSnapshotsChat))]
[JsonSerializable(typeof(CopilotUserResponseQuotaSnapshotsCompletions))]
[JsonSerializable(typeof(CopilotUserResponseQuotaSnapshotsPremiumInteractions))]
[JsonSerializable(typeof(CurrentModel))]
[JsonSerializable(typeof(CurrentToolMetadata))]
[JsonSerializable(typeof(DebugCollectLogsCollectedEntry))]
[JsonSerializable(typeof(DebugCollectLogsDestination))]
[JsonSerializable(typeof(DebugCollectLogsEntry))]
[JsonSerializable(typeof(DebugCollectLogsInclude))]
[JsonSerializable(typeof(DebugCollectLogsRequest))]
[JsonSerializable(typeof(DebugCollectLogsResult))]
[JsonSerializable(typeof(DebugCollectLogsSkippedEntry))]
[JsonSerializable(typeof(DiscoveredCanvas))]
[JsonSerializable(typeof(DiscoveredExtension))]
[JsonSerializable(typeof(DiscoveredExtensionPlugin))]
[JsonSerializable(typeof(DiscoveredExtensions))]
[JsonSerializable(typeof(DiscoveredExtensionsDisableRequest))]
[JsonSerializable(typeof(DiscoveredExtensionsEnableRequest))]
[JsonSerializable(typeof(DiscoveredHook))]
[JsonSerializable(typeof(DiscoveredMcpServer))]
[JsonSerializable(typeof(EnqueueCommandParams))]
[JsonSerializable(typeof(EnqueueCommandResult))]
[JsonSerializable(typeof(EventLogReadRequest))]
[JsonSerializable(typeof(EventLogReleaseInterestResult))]
[JsonSerializable(typeof(EventLogTailResult))]
[JsonSerializable(typeof(EventsReadResult))]
[JsonSerializable(typeof(ExecuteCommandParams))]
[JsonSerializable(typeof(ExecuteCommandResult))]
[JsonSerializable(typeof(Extension))]
[JsonSerializable(typeof(ExtensionLaunchProfile))]
[JsonSerializable(typeof(ExtensionLaunchProviderResolveRequest))]
[JsonSerializable(typeof(ExtensionLaunchProviderResolveResult))]
[JsonSerializable(typeof(ExtensionList))]
[JsonSerializable(typeof(ExtensionsDisableRequest))]
[JsonSerializable(typeof(ExtensionsEnableRequest))]
[JsonSerializable(typeof(ExternalToolTextResultForLlmBinaryResultsForLlm))]
[JsonSerializable(typeof(ExternalToolTextResultForLlmContent))]
[JsonSerializable(typeof(ExternalToolTextResultForLlmContentResourceLinkIcon))]
[JsonSerializable(typeof(FactoryAbortRequest))]
[JsonSerializable(typeof(FactoryAckResult))]
[JsonSerializable(typeof(FactoryAgentOptions))]
[JsonSerializable(typeof(FactoryAgentRequest))]
[JsonSerializable(typeof(FactoryAgentResult))]
[JsonSerializable(typeof(FactoryAgentSummary))]
[JsonSerializable(typeof(FactoryCancelRequest))]
[JsonSerializable(typeof(FactoryCurrentPhase))]
[JsonSerializable(typeof(FactoryDeclaredLimits))]
[JsonSerializable(typeof(FactoryExecuteRequest))]
[JsonSerializable(typeof(FactoryExecuteResult))]
[JsonSerializable(typeof(FactoryGetRunProgressRequest))]
[JsonSerializable(typeof(FactoryGetRunRequest))]
[JsonSerializable(typeof(FactoryJournalGetRequest))]
[JsonSerializable(typeof(FactoryJournalGetResult))]
[JsonSerializable(typeof(FactoryJournalPutRequest))]
[JsonSerializable(typeof(FactoryListRunsRequest))]
[JsonSerializable(typeof(FactoryListRunsResult))]
[JsonSerializable(typeof(FactoryLogLine))]
[JsonSerializable(typeof(FactoryLogRequest))]
[JsonSerializable(typeof(FactoryPauseCheckpointRequest))]
[JsonSerializable(typeof(FactoryPauseInfo))]
[JsonSerializable(typeof(FactoryPauseRequest))]
[JsonSerializable(typeof(FactoryPhaseObservation))]
[JsonSerializable(typeof(FactoryProgressLine))]
[JsonSerializable(typeof(FactoryProgressPage))]
[JsonSerializable(typeof(FactoryResumeRequest))]
[JsonSerializable(typeof(FactoryResumeResult))]
[JsonSerializable(typeof(FactoryRunConsumed))]
[JsonSerializable(typeof(FactoryRunDetail))]
[JsonSerializable(typeof(FactoryRunFailure))]
[JsonSerializable(typeof(FactoryRunLimits))]
[JsonSerializable(typeof(FactoryRunRequest))]
[JsonSerializable(typeof(FactoryRunResult))]
[JsonSerializable(typeof(FactoryRunSummary))]
[JsonSerializable(typeof(FactoryRunTerminal))]
[JsonSerializable(typeof(FactoryToolResumeRequest))]
[JsonSerializable(typeof(FactoryToolRunOptions))]
[JsonSerializable(typeof(FactoryToolRunRequest))]
[JsonSerializable(typeof(FleetStartRequest))]
[JsonSerializable(typeof(FleetStartResult))]
[JsonSerializable(typeof(FolderTrustAddParams))]
[JsonSerializable(typeof(FolderTrustCheckParams))]
[JsonSerializable(typeof(FolderTrustCheckResult))]
[JsonSerializable(typeof(GitHubTelemetryClientInfo))]
[JsonSerializable(typeof(GitHubTelemetryEvent))]
[JsonSerializable(typeof(GitHubTelemetryNotification))]
[JsonSerializable(typeof(GitHubTokenAcquireRequest))]
[JsonSerializable(typeof(GitHubTokenAcquireResult))]
[JsonSerializable(typeof(HandlePendingToolCallRequest))]
[JsonSerializable(typeof(HandlePendingToolCallResult))]
[JsonSerializable(typeof(HistoryAbortManualCompactionResult))]
[JsonSerializable(typeof(HistoryCancelBackgroundCompactionResult))]
[JsonSerializable(typeof(HistoryClearContextRequest))]
[JsonSerializable(typeof(HistoryClearContextResult))]
[JsonSerializable(typeof(HistoryCompactContextWindow))]
[JsonSerializable(typeof(HistoryCompactResult))]
[JsonSerializable(typeof(HistoryListRewindPointsResult))]
[JsonSerializable(typeof(HistoryPreviewRewindRequest))]
[JsonSerializable(typeof(HistoryPreviewRewindResult))]
[JsonSerializable(typeof(HistoryRewindFilePreview))]
[JsonSerializable(typeof(HistoryRewindPoint))]
[JsonSerializable(typeof(HistoryRewindRequest))]
[JsonSerializable(typeof(HistoryRewindResult))]
[JsonSerializable(typeof(HistorySkippedFileRestore))]
[JsonSerializable(typeof(HistorySummarizeForHandoffResult))]
[JsonSerializable(typeof(HistoryTruncateRequest))]
[JsonSerializable(typeof(HistoryTruncateResult))]
[JsonSerializable(typeof(HooksDiscoverRequest))]
[JsonSerializable(typeof(HooksDiscoverResult))]
[JsonSerializable(typeof(IDictionary<string, JsonElement>))]
[JsonSerializable(typeof(IDictionary<string, string>))]
[JsonSerializable(typeof(IList<AccountAllUsers>))]
[JsonSerializable(typeof(IList<AuthValidationError>))]
[JsonSerializable(typeof(IList<SessionAuthStatus>))]
[JsonSerializable(typeof(IList<SessionsClientMetadataEntry>))]
[JsonSerializable(typeof(InstalledPlugin))]
[JsonSerializable(typeof(InstalledPluginInfo))]
[JsonSerializable(typeof(InstructionDiscoveryPath))]
[JsonSerializable(typeof(InstructionDiscoveryPathList))]
[JsonSerializable(typeof(InstructionSource))]
[JsonSerializable(typeof(InstructionsDiscoverRequest))]
[JsonSerializable(typeof(InstructionsGetDiscoveryPathsRequest))]
[JsonSerializable(typeof(InstructionsGetSourcesResult))]
[JsonSerializable(typeof(InterruptMainTurnRequest))]
[JsonSerializable(typeof(InterruptMainTurnResult))]
[JsonSerializable(typeof(LlmInferenceHttpRequestChunkRequest))]
[JsonSerializable(typeof(LlmInferenceHttpRequestChunkResult))]
[JsonSerializable(typeof(LlmInferenceHttpRequestStartRequest))]
[JsonSerializable(typeof(LlmInferenceHttpRequestStartResult))]
[JsonSerializable(typeof(LlmInferenceHttpResponseChunkError))]
[JsonSerializable(typeof(LlmInferenceHttpResponseChunkRequest))]
[JsonSerializable(typeof(LlmInferenceHttpResponseChunkResult))]
[JsonSerializable(typeof(LlmInferenceHttpResponseStartRequest))]
[JsonSerializable(typeof(LlmInferenceHttpResponseStartResult))]
[JsonSerializable(typeof(LlmInferenceSetProviderResult))]
[JsonSerializable(typeof(LocalSessionMetadataValue))]
[JsonSerializable(typeof(LogRequest))]
[JsonSerializable(typeof(LogResult))]
[JsonSerializable(typeof(LspInitializeRequest))]
[JsonSerializable(typeof(ManagedSettingsReadResult))]
[JsonSerializable(typeof(MarketplaceAddResult))]
[JsonSerializable(typeof(MarketplaceBrowseResult))]
[JsonSerializable(typeof(MarketplaceInfo))]
[JsonSerializable(typeof(MarketplaceListResult))]
[JsonSerializable(typeof(MarketplacePluginInfo))]
[JsonSerializable(typeof(MarketplaceRefreshEntry))]
[JsonSerializable(typeof(MarketplaceRefreshResult))]
[JsonSerializable(typeof(MarketplaceRemoveResult))]
[JsonSerializable(typeof(McpAllowedServer))]
[JsonSerializable(typeof(McpAppsCallToolRequest))]
[JsonSerializable(typeof(McpAppsDiagnoseCapability))]
[JsonSerializable(typeof(McpAppsDiagnoseRequest))]
[JsonSerializable(typeof(McpAppsDiagnoseResult))]
[JsonSerializable(typeof(McpAppsDiagnoseServer))]
[JsonSerializable(typeof(McpAppsHostContext))]
[JsonSerializable(typeof(McpAppsHostContextDetails))]
[JsonSerializable(typeof(McpAppsListToolsRequest))]
[JsonSerializable(typeof(McpAppsListToolsResult))]
[JsonSerializable(typeof(McpAppsReadResourceRequest))]
[JsonSerializable(typeof(McpAppsReadResourceResult))]
[JsonSerializable(typeof(McpAppsResourceContent))]
[JsonSerializable(typeof(McpAppsSetHostContextDetails))]
[JsonSerializable(typeof(McpAppsSetHostContextRequest))]
[JsonSerializable(typeof(McpCancelSamplingExecutionParams))]
[JsonSerializable(typeof(McpCancelSamplingExecutionResult))]
[JsonSerializable(typeof(McpConfigAddRequest))]
[JsonSerializable(typeof(McpConfigDisableRequest))]
[JsonSerializable(typeof(McpConfigEnableRequest))]
[JsonSerializable(typeof(McpConfigList))]
[JsonSerializable(typeof(McpConfigRemoveRequest))]
[JsonSerializable(typeof(McpConfigUpdateRequest))]
[JsonSerializable(typeof(McpConfigureGitHubRequest))]
[JsonSerializable(typeof(McpConfigureGitHubResult))]
[JsonSerializable(typeof(McpDisableRequest))]
[JsonSerializable(typeof(McpDiscoverRequest))]
[JsonSerializable(typeof(McpDiscoverResult))]
[JsonSerializable(typeof(McpEnableRequest))]
[JsonSerializable(typeof(McpExecuteSamplingParams))]
[JsonSerializable(typeof(McpExecuteSamplingRequest))]
[JsonSerializable(typeof(McpExecuteSamplingResult))]
[JsonSerializable(typeof(McpFailedServer))]
[JsonSerializable(typeof(McpFilteredServer))]
[JsonSerializable(typeof(McpHeadersHandlePendingHeadersRefreshRequest))]
[JsonSerializable(typeof(McpHeadersHandlePendingHeadersRefreshRequestRequest))]
[JsonSerializable(typeof(McpHeadersHandlePendingHeadersRefreshRequestResult))]
[JsonSerializable(typeof(McpHostState))]
[JsonSerializable(typeof(McpInstallPlan))]
[JsonSerializable(typeof(McpIsServerRunningRequest))]
[JsonSerializable(typeof(McpIsServerRunningResult))]
[JsonSerializable(typeof(McpListToolsRequest))]
[JsonSerializable(typeof(McpListToolsResult))]
[JsonSerializable(typeof(McpOauthAuthenticationStateChangedRequest))]
[JsonSerializable(typeof(McpOauthHandlePendingRequest))]
[JsonSerializable(typeof(McpOauthHandlePendingResult))]
[JsonSerializable(typeof(McpOauthLoginRequest))]
[JsonSerializable(typeof(McpOauthLoginResult))]
[JsonSerializable(typeof(McpOauthPendingRequestResponse))]
[JsonSerializable(typeof(McpOauthProbeRequest))]
[JsonSerializable(typeof(McpOauthProbeResult))]
[JsonSerializable(typeof(McpOauthRespondRequest))]
[JsonSerializable(typeof(McpOauthRespondResult))]
[JsonSerializable(typeof(McpPlanConfigurationChange))]
[JsonSerializable(typeof(McpPlanInstallRequest))]
[JsonSerializable(typeof(McpPlanInstallResult))]
[JsonSerializable(typeof(McpPlanInstallSource))]
[JsonSerializable(typeof(McpPlanPolicyResult))]
[JsonSerializable(typeof(McpPlanProvenance))]
[JsonSerializable(typeof(McpPlanRequiredValue))]
[JsonSerializable(typeof(McpPlanResourceIdentity))]
[JsonSerializable(typeof(McpPlanSecretPlaceholder))]
[JsonSerializable(typeof(McpPlanTarget))]
[JsonSerializable(typeof(McpPlanTransportChoice))]
[JsonSerializable(typeof(McpRegisterExternalClientRequest))]
[JsonSerializable(typeof(McpReloadWithConfigRequest))]
[JsonSerializable(typeof(McpRemoveGitHubResult))]
[JsonSerializable(typeof(McpResource))]
[JsonSerializable(typeof(McpResourceAnnotations))]
[JsonSerializable(typeof(McpResourceContent))]
[JsonSerializable(typeof(McpResourceIcon))]
[JsonSerializable(typeof(McpResourceTemplate))]
[JsonSerializable(typeof(McpResourcesListRequest))]
[JsonSerializable(typeof(McpResourcesListResult))]
[JsonSerializable(typeof(McpResourcesListTemplatesRequest))]
[JsonSerializable(typeof(McpResourcesListTemplatesResult))]
[JsonSerializable(typeof(McpResourcesReadRequest))]
[JsonSerializable(typeof(McpResourcesReadResult))]
[JsonSerializable(typeof(McpRestartServerRequest))]
[JsonSerializable(typeof(McpSamplingExecutionResult))]
[JsonSerializable(typeof(McpServer))]
[JsonSerializable(typeof(McpServerCardReference))]
[JsonSerializable(typeof(McpServerFailureInfo))]
[JsonSerializable(typeof(McpServerList))]
[JsonSerializable(typeof(McpServerNeedsAuthInfo))]
[JsonSerializable(typeof(McpSetEnvValueModeParams))]
[JsonSerializable(typeof(McpSetEnvValueModeResult))]
[JsonSerializable(typeof(McpSourceFile))]
[JsonSerializable(typeof(McpSourcePlugin))]
[JsonSerializable(typeof(McpSourceRef))]
[JsonSerializable(typeof(McpStartServerRequest))]
[JsonSerializable(typeof(McpStartServersResult))]
[JsonSerializable(typeof(McpStopServerRequest))]
[JsonSerializable(typeof(McpTaskMetadata))]
[JsonSerializable(typeof(McpToolUi))]
[JsonSerializable(typeof(McpTools))]
[JsonSerializable(typeof(McpUnregisterExternalClientRequest))]
[JsonSerializable(typeof(MetadataContextAttributionResult))]
[JsonSerializable(typeof(MetadataContextAttributionResultContextAttribution))]
[JsonSerializable(typeof(MetadataContextAttributionResultContextAttributionCategories))]
[JsonSerializable(typeof(MetadataContextAttributionResultContextAttributionCompactions))]
[JsonSerializable(typeof(MetadataContextAttributionResultContextAttributionEntry))]
[JsonSerializable(typeof(MetadataContextHeaviestMessagesRequest))]
[JsonSerializable(typeof(MetadataContextHeaviestMessagesResult))]
[JsonSerializable(typeof(MetadataContextInfoRequest))]
[JsonSerializable(typeof(MetadataContextInfoResult))]
[JsonSerializable(typeof(MetadataContextInfoResultContextInfo))]
[JsonSerializable(typeof(MetadataIsProcessingResult))]
[JsonSerializable(typeof(MetadataRecomputeContextTokensRequest))]
[JsonSerializable(typeof(MetadataRecomputeContextTokensResult))]
[JsonSerializable(typeof(MetadataRecordContextChangeRequest))]
[JsonSerializable(typeof(MetadataRecordContextChangeResult))]
[JsonSerializable(typeof(MetadataSetWorkingDirectoryRequest))]
[JsonSerializable(typeof(MetadataSetWorkingDirectoryResult))]
[JsonSerializable(typeof(MetadataSnapshotRemoteMetadata))]
[JsonSerializable(typeof(MetadataSnapshotRemoteMetadataRepository))]
[JsonSerializable(typeof(MetadataUpdateClientMetadataRequest))]
[JsonSerializable(typeof(ModeSetRequest))]
[JsonSerializable(typeof(ModeSetResult))]
[JsonSerializable(typeof(Model))]
[JsonSerializable(typeof(ModelApplyStartupOverlayRequest))]
[JsonSerializable(typeof(ModelBilling))]
[JsonSerializable(typeof(ModelBillingPromo))]
[JsonSerializable(typeof(ModelBillingTokenPrices))]
[JsonSerializable(typeof(ModelBillingTokenPricesLongContext))]
[JsonSerializable(typeof(ModelCapabilities))]
[JsonSerializable(typeof(ModelCapabilitiesLimits))]
[JsonSerializable(typeof(ModelCapabilitiesLimitsVision))]
[JsonSerializable(typeof(ModelCapabilitiesOverride))]
[JsonSerializable(typeof(ModelCapabilitiesOverrideLimits))]
[JsonSerializable(typeof(ModelCapabilitiesOverrideLimitsVision))]
[JsonSerializable(typeof(ModelCapabilitiesOverrideSupports))]
[JsonSerializable(typeof(ModelCapabilitiesSupports))]
[JsonSerializable(typeof(ModelList))]
[JsonSerializable(typeof(ModelMessage))]
[JsonSerializable(typeof(ModelPickerPersistenceRequest))]
[JsonSerializable(typeof(ModelPickerSettingsContext))]
[JsonSerializable(typeof(ModelPickerSettingsContextEnvironment))]
[JsonSerializable(typeof(ModelPolicy))]
[JsonSerializable(typeof(ModelSetAllowedModelsRequest))]
[JsonSerializable(typeof(ModelSetAllowedModelsResult))]
[JsonSerializable(typeof(ModelSetReasoningEffortRequest))]
[JsonSerializable(typeof(ModelSetReasoningEffortResult))]
[JsonSerializable(typeof(ModelSwitchAutoTierRequest))]
[JsonSerializable(typeof(ModelSwitchAutoTierResult))]
[JsonSerializable(typeof(ModelSwitchConfirmation))]
[JsonSerializable(typeof(ModelSwitchToRequest))]
[JsonSerializable(typeof(ModelSwitchToResult))]
[JsonSerializable(typeof(ModelWarningText))]
[JsonSerializable(typeof(ModelsListRequest))]
[JsonSerializable(typeof(MoveMcpLoadingToBackgroundResult))]
[JsonSerializable(typeof(NameGetResult))]
[JsonSerializable(typeof(NameSetAutoRequest))]
[JsonSerializable(typeof(NameSetAutoResult))]
[JsonSerializable(typeof(NameSetRequest))]
[JsonSerializable(typeof(NamedProviderConfig))]
[JsonSerializable(typeof(OpenCanvasInstance))]
[JsonSerializable(typeof(OptionsUpdateAdditionalContentExclusionPolicy))]
[JsonSerializable(typeof(OptionsUpdateAdditionalContentExclusionPolicyRule))]
[JsonSerializable(typeof(OptionsUpdateAdditionalContentExclusionPolicyRuleSource))]
[JsonSerializable(typeof(PendingPermissionRequest))]
[JsonSerializable(typeof(PendingPermissionRequestList))]
[JsonSerializable(typeof(PermissionDecision))]
[JsonSerializable(typeof(PermissionDecisionApproveForLocationApproval))]
[JsonSerializable(typeof(PermissionDecisionApproveForSessionApproval))]
[JsonSerializable(typeof(PermissionDecisionContext))]
[JsonSerializable(typeof(PermissionDecisionRequest))]
[JsonSerializable(typeof(PermissionLocationAddToolApprovalParams))]
[JsonSerializable(typeof(PermissionLocationApplyParams))]
[JsonSerializable(typeof(PermissionLocationApplyResult))]
[JsonSerializable(typeof(PermissionLocationResolveParams))]
[JsonSerializable(typeof(PermissionLocationResolveResult))]
[JsonSerializable(typeof(PermissionPathsAddParams))]
[JsonSerializable(typeof(PermissionPathsAllowedCheckParams))]
[JsonSerializable(typeof(PermissionPathsAllowedCheckResult))]
[JsonSerializable(typeof(PermissionPathsConfig))]
[JsonSerializable(typeof(PermissionPathsList))]
[JsonSerializable(typeof(PermissionPathsUpdatePrimaryParams))]
[JsonSerializable(typeof(PermissionPathsWorkspaceCheckParams))]
[JsonSerializable(typeof(PermissionPathsWorkspaceCheckResult))]
[JsonSerializable(typeof(PermissionPromptShownNotification))]
[JsonSerializable(typeof(PermissionRequestResult))]
[JsonSerializable(typeof(PermissionRulesSet))]
[JsonSerializable(typeof(PermissionUrlsConfig))]
[JsonSerializable(typeof(PermissionUrlsSetUnrestrictedModeParams))]
[JsonSerializable(typeof(PermissionsConfigureAdditionalContentExclusionPolicy))]
[JsonSerializable(typeof(PermissionsConfigureAdditionalContentExclusionPolicyRule))]
[JsonSerializable(typeof(PermissionsConfigureAdditionalContentExclusionPolicyRuleSource))]
[JsonSerializable(typeof(PermissionsConfigureParams))]
[JsonSerializable(typeof(PermissionsConfigureResult))]
[JsonSerializable(typeof(PermissionsFolderTrustAddTrustedResult))]
[JsonSerializable(typeof(PermissionsGetModeRequest))]
[JsonSerializable(typeof(PermissionsGetModeResult))]
[JsonSerializable(typeof(PermissionsLocationsAddToolApprovalDetails))]
[JsonSerializable(typeof(PermissionsLocationsAddToolApprovalResult))]
[JsonSerializable(typeof(PermissionsModifyRulesParams))]
[JsonSerializable(typeof(PermissionsModifyRulesResult))]
[JsonSerializable(typeof(PermissionsNotifyPromptShownResult))]
[JsonSerializable(typeof(PermissionsPathsAddResult))]
[JsonSerializable(typeof(PermissionsPathsListRequest))]
[JsonSerializable(typeof(PermissionsPathsUpdatePrimaryResult))]
[JsonSerializable(typeof(PermissionsPendingRequestsRequest))]
[JsonSerializable(typeof(PermissionsResetSessionApprovalsRequest))]
[JsonSerializable(typeof(PermissionsResetSessionApprovalsResult))]
[JsonSerializable(typeof(PermissionsSetApproveAllRequest))]
[JsonSerializable(typeof(PermissionsSetApproveAllResult))]
[JsonSerializable(typeof(PermissionsSetModeRequest))]
[JsonSerializable(typeof(PermissionsSetModeResult))]
[JsonSerializable(typeof(PermissionsSetRequiredRequest))]
[JsonSerializable(typeof(PermissionsSetRequiredResult))]
[JsonSerializable(typeof(PermissionsUrlsSetUnrestrictedModeResult))]
[JsonSerializable(typeof(PingRequest))]
[JsonSerializable(typeof(PingResult))]
[JsonSerializable(typeof(PlanReadResult))]
[JsonSerializable(typeof(PlanReadSqlTodosResult))]
[JsonSerializable(typeof(PlanReadSqlTodosWithDependenciesResult))]
[JsonSerializable(typeof(PlanSqlTodoDependency))]
[JsonSerializable(typeof(PlanSqlTodosRow))]
[JsonSerializable(typeof(PlanUpdateRequest))]
[JsonSerializable(typeof(Plugin))]
[JsonSerializable(typeof(PluginInstallResult))]
[JsonSerializable(typeof(PluginList))]
[JsonSerializable(typeof(PluginListResult))]
[JsonSerializable(typeof(PluginUpdateAllEntry))]
[JsonSerializable(typeof(PluginUpdateAllResult))]
[JsonSerializable(typeof(PluginUpdateResult))]
[JsonSerializable(typeof(PluginsBuiltinSetRequest))]
[JsonSerializable(typeof(PluginsDisableRequest))]
[JsonSerializable(typeof(PluginsEnableRequest))]
[JsonSerializable(typeof(PluginsInstallRequest))]
[JsonSerializable(typeof(PluginsMarketplacesAddRequest))]
[JsonSerializable(typeof(PluginsMarketplacesBrowseRequest))]
[JsonSerializable(typeof(PluginsMarketplacesRefreshRequest))]
[JsonSerializable(typeof(PluginsMarketplacesRemoveRequest))]
[JsonSerializable(typeof(PluginsUninstallRequest))]
[JsonSerializable(typeof(PluginsUpdateRequest))]
[JsonSerializable(typeof(ProtocolExternalToolDefinition))]
[JsonSerializable(typeof(ProviderAddRequest))]
[JsonSerializable(typeof(ProviderAddResult))]
[JsonSerializable(typeof(ProviderConfig))]
[JsonSerializable(typeof(ProviderConfigAzure))]
[JsonSerializable(typeof(ProviderEndpoint))]
[JsonSerializable(typeof(ProviderModelConfig))]
[JsonSerializable(typeof(ProviderSessionToken))]
[JsonSerializable(typeof(ProviderTokenAcquireRequest))]
[JsonSerializable(typeof(ProviderTokenAcquireResult))]
[JsonSerializable(typeof(PushAttachment))]
[JsonSerializable(typeof(PushAttachmentFileLineRange))]
[JsonSerializable(typeof(PushAttachmentGitHubFileDiffSide))]
[JsonSerializable(typeof(PushAttachmentGitHubTreeComparisonSide))]
[JsonSerializable(typeof(PushAttachmentSelectionDetails))]
[JsonSerializable(typeof(PushAttachmentSelectionDetailsEnd))]
[JsonSerializable(typeof(PushAttachmentSelectionDetailsStart))]
[JsonSerializable(typeof(PushGitHubRepoRef))]
[JsonSerializable(typeof(QueueBeginDeferredIdleDrainRequest))]
[JsonSerializable(typeof(QueueBeginDeferredIdleDrainResult))]
[JsonSerializable(typeof(QueueConsumeSystemNotificationsRequest))]
[JsonSerializable(typeof(QueueDeferSessionIdleRequest))]
[JsonSerializable(typeof(QueueDuplicateAtRequest))]
[JsonSerializable(typeof(QueueDuplicateAtResult))]
[JsonSerializable(typeof(QueueEnqueueResumePendingResult))]
[JsonSerializable(typeof(QueueFinishDeferredIdleDrainRequest))]
[JsonSerializable(typeof(QueueFinishDeferredIdleDrainResult))]
[JsonSerializable(typeof(QueueHasPendingResult))]
[JsonSerializable(typeof(QueueInsertAtRequest))]
[JsonSerializable(typeof(QueueInsertAtResult))]
[JsonSerializable(typeof(QueueInsertMessage))]
[JsonSerializable(typeof(QueueMoveItemRequest))]
[JsonSerializable(typeof(QueueMoveItemResult))]
[JsonSerializable(typeof(QueuePendingItems))]
[JsonSerializable(typeof(QueuePendingItemsResult))]
[JsonSerializable(typeof(QueueRemoveAtRequest))]
[JsonSerializable(typeof(QueueRemoveAtResult))]
[JsonSerializable(typeof(QueueRemoveMostRecentResult))]
[JsonSerializable(typeof(QueueSendNowRequest))]
[JsonSerializable(typeof(QueueSendNowResult))]
[JsonSerializable(typeof(QueueSetDrainPausedRequest))]
[JsonSerializable(typeof(QueueSnapshotResult))]
[JsonSerializable(typeof(QueueUpdateTextRequest))]
[JsonSerializable(typeof(QueueUpdateTextResult))]
[JsonSerializable(typeof(QueuedCommandResult))]
[JsonSerializable(typeof(RegisterEventInterestParams))]
[JsonSerializable(typeof(RegisterEventInterestResult))]
[JsonSerializable(typeof(RegisterExtensionToolsParams))]
[JsonSerializable(typeof(RegisterExtensionToolsResult))]
[JsonSerializable(typeof(ReleaseEventInterestParams))]
[JsonSerializable(typeof(RemoteControlConfig))]
[JsonSerializable(typeof(RemoteControlConfigExistingMcSession))]
[JsonSerializable(typeof(RemoteControlStatus))]
[JsonSerializable(typeof(RemoteControlStatusResult))]
[JsonSerializable(typeof(RemoteControlStopResult))]
[JsonSerializable(typeof(RemoteControlTransferResult))]
[JsonSerializable(typeof(RemoteEnableRequest))]
[JsonSerializable(typeof(RemoteEnableResult))]
[JsonSerializable(typeof(RemoteNotifySteerableChangedRequest))]
[JsonSerializable(typeof(RemoteNotifySteerableChangedResult))]
[JsonSerializable(typeof(RemoteSessionConnectionResult))]
[JsonSerializable(typeof(RemoteSessionMetadataRepository))]
[JsonSerializable(typeof(RemoteSessionMetadataValue))]
[JsonSerializable(typeof(RunOptions))]
[JsonSerializable(typeof(SandboxConfig))]
[JsonSerializable(typeof(SandboxConfigAuth))]
[JsonSerializable(typeof(SandboxConfigUserPolicy))]
[JsonSerializable(typeof(SandboxConfigUserPolicyExperimental))]
[JsonSerializable(typeof(SandboxConfigUserPolicyExperimentalSeatbelt))]
[JsonSerializable(typeof(SandboxConfigUserPolicyFilesystem))]
[JsonSerializable(typeof(SandboxConfigUserPolicyNetwork))]
[JsonSerializable(typeof(SandboxConfigUserPolicyNetworkProxy))]
[JsonSerializable(typeof(SandboxConfigUserPolicySeatbelt))]
[JsonSerializable(typeof(SandboxDisableForSessionRequest))]
[JsonSerializable(typeof(SandboxDisableForSessionResult))]
[JsonSerializable(typeof(SandboxEnforcementStatus))]
[JsonSerializable(typeof(ScheduleAddAtRequest))]
[JsonSerializable(typeof(ScheduleAddCronRequest))]
[JsonSerializable(typeof(ScheduleAddRequest))]
[JsonSerializable(typeof(ScheduleAddResult))]
[JsonSerializable(typeof(ScheduleAddSelfPacedRequest))]
[JsonSerializable(typeof(ScheduleEntry))]
[JsonSerializable(typeof(ScheduleHasSelfPacedResult))]
[JsonSerializable(typeof(ScheduleList))]
[JsonSerializable(typeof(ScheduleRearmSelfPacedRequest))]
[JsonSerializable(typeof(ScheduleStopRequest))]
[JsonSerializable(typeof(ScheduleStopResult))]
[JsonSerializable(typeof(SecretsAddFilterValuesRequest))]
[JsonSerializable(typeof(SecretsAddFilterValuesResult))]
[JsonSerializable(typeof(SendAttachmentsToMessageParams))]
[JsonSerializable(typeof(SendMessageItem))]
[JsonSerializable(typeof(SendMessagesRequest))]
[JsonSerializable(typeof(SendMessagesResult))]
[JsonSerializable(typeof(SendRequest))]
[JsonSerializable(typeof(SendResult))]
[JsonSerializable(typeof(SendSystemNotificationRequest))]
[JsonSerializable(typeof(ServerAgentList))]
[JsonSerializable(typeof(ServerInstructionSourceList))]
[JsonSerializable(typeof(ServerSkill))]
[JsonSerializable(typeof(ServerSkillList))]
[JsonSerializable(typeof(SessionActivity))]
[JsonSerializable(typeof(SessionAgentDeselectRequest))]
[JsonSerializable(typeof(SessionAgentGetCurrentRequest))]
[JsonSerializable(typeof(SessionAgentListRequest))]
[JsonSerializable(typeof(SessionAgentListRequestWithSession))]
[JsonSerializable(typeof(SessionAgentReloadRequest))]
[JsonSerializable(typeof(SessionAuthLoginRequest))]
[JsonSerializable(typeof(SessionAuthLogoutUserRequest))]
[JsonSerializable(typeof(SessionAuthStatus))]
[JsonSerializable(typeof(SessionAuthSwitchRequest))]
[JsonSerializable(typeof(SessionAutopilotObjectiveGetStateRequest))]
[JsonSerializable(typeof(SessionBulkDeleteResult))]
[JsonSerializable(typeof(SessionCancelAllBackgroundAgentsRequest))]
[JsonSerializable(typeof(SessionCanvasListOpenRequest))]
[JsonSerializable(typeof(SessionCanvasListRequest))]
[JsonSerializable(typeof(SessionCommandsListRequest))]
[JsonSerializable(typeof(SessionCommandsListRequestWithSession))]
[JsonSerializable(typeof(SessionCompletionItem))]
[JsonSerializable(typeof(SessionCompletionsGetTriggerCharactersRequest))]
[JsonSerializable(typeof(SessionContext))]
[JsonSerializable(typeof(SessionEnrichMetadataResult))]
[JsonSerializable(typeof(SessionEventLogTailRequest))]
[JsonSerializable(typeof(SessionExtensionsListRequest))]
[JsonSerializable(typeof(SessionExtensionsReloadRequest))]
[JsonSerializable(typeof(SessionFactoryPauseAtCheckpointResult))]
[JsonSerializable(typeof(SessionFsAppendFileRequest))]
[JsonSerializable(typeof(SessionFsError))]
[JsonSerializable(typeof(SessionFsExistsRequest))]
[JsonSerializable(typeof(SessionFsExistsResult))]
[JsonSerializable(typeof(SessionFsMkdirRequest))]
[JsonSerializable(typeof(SessionFsReadFileRequest))]
[JsonSerializable(typeof(SessionFsReadFileResult))]
[JsonSerializable(typeof(SessionFsReaddirRequest))]
[JsonSerializable(typeof(SessionFsReaddirResult))]
[JsonSerializable(typeof(SessionFsReaddirWithTypesEntry))]
[JsonSerializable(typeof(SessionFsReaddirWithTypesRequest))]
[JsonSerializable(typeof(SessionFsReaddirWithTypesResult))]
[JsonSerializable(typeof(SessionFsRenameRequest))]
[JsonSerializable(typeof(SessionFsRmRequest))]
[JsonSerializable(typeof(SessionFsSetProviderCapabilities))]
[JsonSerializable(typeof(SessionFsSetProviderRequest))]
[JsonSerializable(typeof(SessionFsSetProviderResult))]
[JsonSerializable(typeof(SessionFsSqliteExistsRequest))]
[JsonSerializable(typeof(SessionFsSqliteExistsResult))]
[JsonSerializable(typeof(SessionFsSqliteQueryRequest))]
[JsonSerializable(typeof(SessionFsSqliteQueryResult))]
[JsonSerializable(typeof(SessionFsSqliteTransactionError))]
[JsonSerializable(typeof(SessionFsSqliteTransactionRequest))]
[JsonSerializable(typeof(SessionFsSqliteTransactionResult))]
[JsonSerializable(typeof(SessionFsSqliteTransactionStatement))]
[JsonSerializable(typeof(SessionFsStatRequest))]
[JsonSerializable(typeof(SessionFsStatResult))]
[JsonSerializable(typeof(SessionFsWriteFileRequest))]
[JsonSerializable(typeof(SessionGitHubAuthGetAllAuthAvailableRequest))]
[JsonSerializable(typeof(SessionGitHubAuthGetCurrentAuthInfoRequest))]
[JsonSerializable(typeof(SessionGitHubAuthGetStatusRequest))]
[JsonSerializable(typeof(SessionGitHubAuthLastAuthErrorsRequest))]
[JsonSerializable(typeof(SessionGitHubAuthLogoutRequest))]
[JsonSerializable(typeof(SessionGitHubAuthRefreshCopilotUserRequest))]
[JsonSerializable(typeof(SessionHistoryAbortManualCompactionRequest))]
[JsonSerializable(typeof(SessionHistoryCancelBackgroundCompactionRequest))]
[JsonSerializable(typeof(SessionHistoryCompactRequest))]
[JsonSerializable(typeof(SessionHistoryCompactRequestWithSession))]
[JsonSerializable(typeof(SessionHistoryListRewindPointsRequest))]
[JsonSerializable(typeof(SessionHistorySummarizeForHandoffRequest))]
[JsonSerializable(typeof(SessionInstalledPlugin))]
[JsonSerializable(typeof(SessionInstructionsGetSourcesRequest))]
[JsonSerializable(typeof(SessionLimitPredictionBaselineData))]
[JsonSerializable(typeof(SessionLimitPredictionDetails))]
[JsonSerializable(typeof(SessionLimitPredictionPredictRequest))]
[JsonSerializable(typeof(SessionLimitPredictionPredictRequestWithSession))]
[JsonSerializable(typeof(SessionLimitPredictionResult))]
[JsonSerializable(typeof(SessionLimitPredictionTierOption))]
[JsonSerializable(typeof(SessionList))]
[JsonSerializable(typeof(SessionListEntry))]
[JsonSerializable(typeof(SessionListFilter))]
[JsonSerializable(typeof(SessionLoadDeferredRepoHooksResult))]
[JsonSerializable(typeof(SessionMcpAppsGetHostContextRequest))]
[JsonSerializable(typeof(SessionMcpListRequest))]
[JsonSerializable(typeof(SessionMcpMoveLoadingToBackgroundRequest))]
[JsonSerializable(typeof(SessionMcpReloadRequest))]
[JsonSerializable(typeof(SessionMcpRemoveGitHubRequest))]
[JsonSerializable(typeof(SessionMetadataActivityRequest))]
[JsonSerializable(typeof(SessionMetadataGetClientMetadataRequest))]
[JsonSerializable(typeof(SessionMetadataGetContextAttributionRequest))]
[JsonSerializable(typeof(SessionMetadataIsProcessingRequest))]
[JsonSerializable(typeof(SessionMetadataSnapshot))]
[JsonSerializable(typeof(SessionMetadataSnapshotRequest))]
[JsonSerializable(typeof(SessionMetadataSnapshotWorkspace))]
[JsonSerializable(typeof(SessionModeGetRequest))]
[JsonSerializable(typeof(SessionModelGetCurrentRequest))]
[JsonSerializable(typeof(SessionModelList))]
[JsonSerializable(typeof(SessionModelListRequest))]
[JsonSerializable(typeof(SessionModelListRequestWithSession))]
[JsonSerializable(typeof(SessionModelPriceCategory))]
[JsonSerializable(typeof(SessionNameGetRequest))]
[JsonSerializable(typeof(SessionOpenResult))]
[JsonSerializable(typeof(SessionPlanDeleteRequest))]
[JsonSerializable(typeof(SessionPlanReadRequest))]
[JsonSerializable(typeof(SessionPlanReadSqlTodosRequest))]
[JsonSerializable(typeof(SessionPlanReadSqlTodosWithDependenciesRequest))]
[JsonSerializable(typeof(SessionPluginsListRequest))]
[JsonSerializable(typeof(SessionPluginsReloadRequest))]
[JsonSerializable(typeof(SessionPluginsReloadRequestWithSession))]
[JsonSerializable(typeof(SessionProviderGetEndpointRequest))]
[JsonSerializable(typeof(SessionProviderGetEndpointRequestWithSession))]
[JsonSerializable(typeof(SessionPruneResult))]
[JsonSerializable(typeof(SessionQueueClearRequest))]
[JsonSerializable(typeof(SessionQueueEnqueueResumePendingRequest))]
[JsonSerializable(typeof(SessionQueueHasPendingRequest))]
[JsonSerializable(typeof(SessionQueuePendingItemsRequest))]
[JsonSerializable(typeof(SessionQueueProcessRequest))]
[JsonSerializable(typeof(SessionQueueRemoveMostRecentRequest))]
[JsonSerializable(typeof(SessionQueueSnapshotRequest))]
[JsonSerializable(typeof(SessionRemoteDisableRequest))]
[JsonSerializable(typeof(SessionSandboxGetEnforcementStatusRequest))]
[JsonSerializable(typeof(SessionScheduleHasSelfPacedRequest))]
[JsonSerializable(typeof(SessionScheduleHydrateRequest))]
[JsonSerializable(typeof(SessionScheduleListRequest))]
[JsonSerializable(typeof(SessionSetCredentialsParams))]
[JsonSerializable(typeof(SessionSetCredentialsResult))]
[JsonSerializable(typeof(SessionSettingsBuiltInToolAvailabilitySnapshot))]
[JsonSerializable(typeof(SessionSettingsEvaluatePredicateRequest))]
[JsonSerializable(typeof(SessionSettingsEvaluatePredicateResult))]
[JsonSerializable(typeof(SessionSettingsJobSnapshot))]
[JsonSerializable(typeof(SessionSettingsModelSnapshot))]
[JsonSerializable(typeof(SessionSettingsOnlineEvaluationSnapshot))]
[JsonSerializable(typeof(SessionSettingsRepoSnapshot))]
[JsonSerializable(typeof(SessionSettingsSnapshot))]
[JsonSerializable(typeof(SessionSettingsSnapshotRequest))]
[JsonSerializable(typeof(SessionSettingsValidationSnapshot))]
[JsonSerializable(typeof(SessionSizes))]
[JsonSerializable(typeof(SessionSkillsEnsureLoadedRequest))]
[JsonSerializable(typeof(SessionSkillsGetInvokedRequest))]
[JsonSerializable(typeof(SessionSkillsListRequest))]
[JsonSerializable(typeof(SessionSkillsReloadRequest))]
[JsonSerializable(typeof(SessionSuspendRequest))]
[JsonSerializable(typeof(SessionTasksGetCurrentPromotableRequest))]
[JsonSerializable(typeof(SessionTasksListRequest))]
[JsonSerializable(typeof(SessionTasksPromoteCurrentToBackgroundRequest))]
[JsonSerializable(typeof(SessionTasksRefreshRequest))]
[JsonSerializable(typeof(SessionTasksWaitForPendingRequest))]
[JsonSerializable(typeof(SessionTelemetryEngagement))]
[JsonSerializable(typeof(SessionTelemetryGetEngagementIdRequest))]
[JsonSerializable(typeof(SessionToolsGetCurrentMetadataRequest))]
[JsonSerializable(typeof(SessionToolsInitializeAndValidateRequest))]
[JsonSerializable(typeof(SessionUiRegisterDirectAutoModeSwitchHandlerRequest))]
[JsonSerializable(typeof(SessionUpdateOptionsParams))]
[JsonSerializable(typeof(SessionUpdateOptionsResult))]
[JsonSerializable(typeof(SessionUsageGetMetricsRequest))]
[JsonSerializable(typeof(SessionVisibilityGetRequest))]
[JsonSerializable(typeof(SessionWorkingDirectoryContext))]
[JsonSerializable(typeof(SessionWorkspacesAutopilotObjectiveExistsRequest))]
[JsonSerializable(typeof(SessionWorkspacesDeleteAutopilotObjectiveRequest))]
[JsonSerializable(typeof(SessionWorkspacesGetWorkspaceRequest))]
[JsonSerializable(typeof(SessionWorkspacesListCheckpointsRequest))]
[JsonSerializable(typeof(SessionWorkspacesListFilesRequest))]
[JsonSerializable(typeof(SessionWorkspacesReadAutopilotObjectiveRequest))]
[JsonSerializable(typeof(SessionsBulkDeleteRequest))]
[JsonSerializable(typeof(SessionsCheckInUseRequest))]
[JsonSerializable(typeof(SessionsCheckInUseResult))]
[JsonSerializable(typeof(SessionsClientMetadataEntry))]
[JsonSerializable(typeof(SessionsCloseRequest))]
[JsonSerializable(typeof(SessionsCloseResult))]
[JsonSerializable(typeof(SessionsDeleteRequest))]
[JsonSerializable(typeof(SessionsEnrichMetadataRequest))]
[JsonSerializable(typeof(SessionsFindByPrefixRequest))]
[JsonSerializable(typeof(SessionsFindByPrefixResult))]
[JsonSerializable(typeof(SessionsFindByTaskIDRequest))]
[JsonSerializable(typeof(SessionsFindByTaskIDResult))]
[JsonSerializable(typeof(SessionsForkRequest))]
[JsonSerializable(typeof(SessionsForkResult))]
[JsonSerializable(typeof(SessionsGetBoardEntryCountRequest))]
[JsonSerializable(typeof(SessionsGetBoardEntryCountResult))]
[JsonSerializable(typeof(SessionsGetClientMetadataRequest))]
[JsonSerializable(typeof(SessionsGetEventFilePathRequest))]
[JsonSerializable(typeof(SessionsGetEventFilePathResult))]
[JsonSerializable(typeof(SessionsGetLastForContextRequest))]
[JsonSerializable(typeof(SessionsGetLastForContextResult))]
[JsonSerializable(typeof(SessionsGetMetadataRequest))]
[JsonSerializable(typeof(SessionsGetMetadataResult))]
[JsonSerializable(typeof(SessionsGetPersistedRemoteSteerableRequest))]
[JsonSerializable(typeof(SessionsGetPersistedRemoteSteerableResult))]
[JsonSerializable(typeof(SessionsListNonEmptySessionIdsRequest))]
[JsonSerializable(typeof(SessionsListNonEmptySessionIdsResult))]
[JsonSerializable(typeof(SessionsListRequest))]
[JsonSerializable(typeof(SessionsLoadDeferredRepoHooksRequest))]
[JsonSerializable(typeof(SessionsOpenProgress))]
[JsonSerializable(typeof(SessionsPruneOldRequest))]
[JsonSerializable(typeof(SessionsReadPersistedEventsRequest))]
[JsonSerializable(typeof(SessionsRegisterExtensionToolsOnSessionOptions))]
[JsonSerializable(typeof(SessionsReleaseLockRequest))]
[JsonSerializable(typeof(SessionsReleaseLockResult))]
[JsonSerializable(typeof(SessionsReloadPluginHooksRequest))]
[JsonSerializable(typeof(SessionsReloadPluginHooksResult))]
[JsonSerializable(typeof(SessionsSaveRequest))]
[JsonSerializable(typeof(SessionsSaveResult))]
[JsonSerializable(typeof(SessionsSetAdditionalPluginsRequest))]
[JsonSerializable(typeof(SessionsSetAdditionalPluginsResult))]
[JsonSerializable(typeof(SessionsSetRemoteControlSteeringRequest))]
[JsonSerializable(typeof(SessionsStartRemoteControlRequest))]
[JsonSerializable(typeof(SessionsStopRemoteControlRequest))]
[JsonSerializable(typeof(SessionsTransferRemoteControlRequest))]
[JsonSerializable(typeof(SettableAuthInfo))]
[JsonSerializable(typeof(ShellCancelUserRequestedRequest))]
[JsonSerializable(typeof(ShellCredentials))]
[JsonSerializable(typeof(ShellExecRequest))]
[JsonSerializable(typeof(ShellExecResult))]
[JsonSerializable(typeof(ShellExecuteUserRequestedRequest))]
[JsonSerializable(typeof(ShellInitScript))]
[JsonSerializable(typeof(ShellKillRequest))]
[JsonSerializable(typeof(ShellKillResult))]
[JsonSerializable(typeof(ShellOptions))]
[JsonSerializable(typeof(ShutdownRequest))]
[JsonSerializable(typeof(Skill))]
[JsonSerializable(typeof(SkillDiscoveryPath))]
[JsonSerializable(typeof(SkillDiscoveryPathList))]
[JsonSerializable(typeof(SkillList))]
[JsonSerializable(typeof(SkillsConfigSetDisabledSkillsRequest))]
[JsonSerializable(typeof(SkillsConfigSetSkillDisabledRequest))]
[JsonSerializable(typeof(SkillsDisableRequest))]
[JsonSerializable(typeof(SkillsDiscoverRequest))]
[JsonSerializable(typeof(SkillsEnableRequest))]
[JsonSerializable(typeof(SkillsGetDiscoveryPathsRequest))]
[JsonSerializable(typeof(SkillsGetInvokedResult))]
[JsonSerializable(typeof(SkillsInvokedSkill))]
[JsonSerializable(typeof(SkillsLoadDiagnostics))]
[JsonSerializable(typeof(SlashCommandInfo))]
[JsonSerializable(typeof(SlashCommandInput))]
[JsonSerializable(typeof(SlashCommandInputChoice))]
[JsonSerializable(typeof(SlashCommandInvocationResult))]
[JsonSerializable(typeof(SlashCommandInvocationResultSetModelRevertOnCancel))]
[JsonSerializable(typeof(SlashCommandModelPickerDialog))]
[JsonSerializable(typeof(SlashCommandSelectSubcommandOption))]
[JsonSerializable(typeof(SlashCommandTimelineEntry))]
[JsonSerializable(typeof(SubagentSettingsEntry))]
[JsonSerializable(typeof(TaskClientInfo))]
[JsonSerializable(typeof(TaskClientOwner))]
[JsonSerializable(typeof(TaskClientUpdate))]
[JsonSerializable(typeof(TaskCompleteData))]
[JsonSerializable(typeof(TaskCompletionDecision))]
[JsonSerializable(typeof(TaskInfo))]
[JsonSerializable(typeof(TaskList))]
[JsonSerializable(typeof(TaskProgress))]
[JsonSerializable(typeof(TaskProgressLine))]
[JsonSerializable(typeof(TasksCancelRequest))]
[JsonSerializable(typeof(TasksCancelResult))]
[JsonSerializable(typeof(TasksGetCurrentPromotableResult))]
[JsonSerializable(typeof(TasksGetProgressRequest))]
[JsonSerializable(typeof(TasksGetProgressResult))]
[JsonSerializable(typeof(TasksPromoteCurrentToBackgroundResult))]
[JsonSerializable(typeof(TasksPromoteToBackgroundRequest))]
[JsonSerializable(typeof(TasksPromoteToBackgroundResult))]
[JsonSerializable(typeof(TasksRefreshResult))]
[JsonSerializable(typeof(TasksRegisterRequest))]
[JsonSerializable(typeof(TasksRegisterResult))]
[JsonSerializable(typeof(TasksRemoveRequest))]
[JsonSerializable(typeof(TasksRemoveResult))]
[JsonSerializable(typeof(TasksSendMessageRequest))]
[JsonSerializable(typeof(TasksSendMessageResult))]
[JsonSerializable(typeof(TasksStartAgentRequest))]
[JsonSerializable(typeof(TasksStartAgentResult))]
[JsonSerializable(typeof(TasksUpdateRequest))]
[JsonSerializable(typeof(TasksUpdateResult))]
[JsonSerializable(typeof(TasksWaitForPendingResult))]
[JsonSerializable(typeof(TelemetrySetFeatureOverridesRequest))]
[JsonSerializable(typeof(Tool))]
[JsonSerializable(typeof(ToolList))]
[JsonSerializable(typeof(ToolResultExpanded))]
[JsonSerializable(typeof(ToolResultNewMessage))]
[JsonSerializable(typeof(ToolsExecuteRequest))]
[JsonSerializable(typeof(ToolsGetBuiltinDescriptorsRequest))]
[JsonSerializable(typeof(ToolsGetBuiltinDescriptorsResult))]
[JsonSerializable(typeof(ToolsGetCurrentMetadataResult))]
[JsonSerializable(typeof(ToolsInitializeAndValidateResult))]
[JsonSerializable(typeof(ToolsListRequest))]
[JsonSerializable(typeof(ToolsSetRequest))]
[JsonSerializable(typeof(ToolsSetResult))]
[JsonSerializable(typeof(ToolsShellDescriptorConfig))]
[JsonSerializable(typeof(ToolsTaskCompleteEventDataRequest))]
[JsonSerializable(typeof(ToolsUpdateSubagentSettingsResult))]
[JsonSerializable(typeof(UIElicitationRequest))]
[JsonSerializable(typeof(UIElicitationRequestMeta))]
[JsonSerializable(typeof(UIElicitationResponse))]
[JsonSerializable(typeof(UIElicitationResponseMeta))]
[JsonSerializable(typeof(UIElicitationResult))]
[JsonSerializable(typeof(UIElicitationSchema))]
[JsonSerializable(typeof(UIEphemeralQueryRequest))]
[JsonSerializable(typeof(UIEphemeralQueryResult))]
[JsonSerializable(typeof(UIExitPlanModeResponse))]
[JsonSerializable(typeof(UIHandlePendingAutoModeSwitchRequest))]
[JsonSerializable(typeof(UIHandlePendingElicitationRequest))]
[JsonSerializable(typeof(UIHandlePendingExitPlanModeRequest))]
[JsonSerializable(typeof(UIHandlePendingResult))]
[JsonSerializable(typeof(UIHandlePendingSamplingRequest))]
[JsonSerializable(typeof(UIHandlePendingSamplingResponse))]
[JsonSerializable(typeof(UIHandlePendingSessionLimitsExhaustedRequest))]
[JsonSerializable(typeof(UIHandlePendingUserInputRequest))]
[JsonSerializable(typeof(UIRegisterDirectAutoModeSwitchHandlerResult))]
[JsonSerializable(typeof(UISessionLimitsExhaustedResponse))]
[JsonSerializable(typeof(UIUnregisterDirectAutoModeSwitchHandlerRequest))]
[JsonSerializable(typeof(UIUnregisterDirectAutoModeSwitchHandlerResult))]
[JsonSerializable(typeof(UIUserInputResponse))]
[JsonSerializable(typeof(UpdateSubagentSettingsRequest))]
[JsonSerializable(typeof(UpdateSubagentSettingsRequestSubagents))]
[JsonSerializable(typeof(UsageGetMetricsResult))]
[JsonSerializable(typeof(UsageMetricsAgentMetric))]
[JsonSerializable(typeof(UsageMetricsCodeChanges))]
[JsonSerializable(typeof(UsageMetricsModelMetric))]
[JsonSerializable(typeof(UsageMetricsModelMetricRequests))]
[JsonSerializable(typeof(UsageMetricsModelMetricTokenDetail))]
[JsonSerializable(typeof(UsageMetricsModelMetricUsage))]
[JsonSerializable(typeof(UsageMetricsTokenDetail))]
[JsonSerializable(typeof(UserRequestedShellCommandResult))]
[JsonSerializable(typeof(UserSettingMetadata))]
[JsonSerializable(typeof(UserSettingsGetResult))]
[JsonSerializable(typeof(UserSettingsSetRequest))]
[JsonSerializable(typeof(UserSettingsSetResult))]
[JsonSerializable(typeof(VisibilityGetResult))]
[JsonSerializable(typeof(VisibilitySetRequest))]
[JsonSerializable(typeof(VisibilitySetResult))]
[JsonSerializable(typeof(WorkspaceDiffFileChange))]
[JsonSerializable(typeof(WorkspaceDiffResult))]
[JsonSerializable(typeof(WorkspacesAddSummaryRequest))]
[JsonSerializable(typeof(WorkspacesAddSummaryResult))]
[JsonSerializable(typeof(WorkspacesAddSummaryResultSummary))]
[JsonSerializable(typeof(WorkspacesAddSummaryResultWorkspace))]
[JsonSerializable(typeof(WorkspacesAutopilotObjectiveExistsResult))]
[JsonSerializable(typeof(WorkspacesCheckpoints))]
[JsonSerializable(typeof(WorkspacesCreateFileRequest))]
[JsonSerializable(typeof(WorkspacesDeleteAutopilotObjectiveResult))]
[JsonSerializable(typeof(WorkspacesDiffRequest))]
[JsonSerializable(typeof(WorkspacesEnsureRequest))]
[JsonSerializable(typeof(WorkspacesGetWorkspaceResult))]
[JsonSerializable(typeof(WorkspacesGetWorkspaceResultWorkspace))]
[JsonSerializable(typeof(WorkspacesListCheckpointsResult))]
[JsonSerializable(typeof(WorkspacesListFilesResult))]
[JsonSerializable(typeof(WorkspacesReadAutopilotObjectiveResult))]
[JsonSerializable(typeof(WorkspacesReadCheckpointRequest))]
[JsonSerializable(typeof(WorkspacesReadCheckpointResult))]
[JsonSerializable(typeof(WorkspacesReadFileRequest))]
[JsonSerializable(typeof(WorkspacesReadFileResult))]
[JsonSerializable(typeof(WorkspacesSaveLargePasteRequest))]
[JsonSerializable(typeof(WorkspacesSaveLargePasteResult))]
[JsonSerializable(typeof(WorkspacesSaveLargePasteResultSaved))]
[JsonSerializable(typeof(WorkspacesTruncateSummariesRequest))]
[JsonSerializable(typeof(WorkspacesUpdateMetadataRequest))]
[JsonSerializable(typeof(WorkspacesWriteAutopilotObjectiveRequest))]
[JsonSerializable(typeof(WorkspacesWriteAutopilotObjectiveResult))]
internal partial class RpcJsonContext : JsonSerializerContext;