github_copilot_sdk/generated/

rpc.rs

//! Auto-generated typed JSON-RPC namespace — do not edit manually.
//!
//! Generated from `api.schema.json` by `scripts/codegen/rust.ts`. The
//! [`ClientRpc`] and [`SessionRpc`] view structs let callers reach every
//! protocol method through a typed namespace tree, so wire method names
//! and request/response shapes live in exactly one place — this file.

#![allow(missing_docs)]
#![allow(clippy::too_many_arguments)]
#![allow(deprecated)]
#![allow(dead_code)]

use super::api_types::{rpc_methods, *};
use super::session_events::SessionMode;
use crate::session::Session;
use crate::{Client, Error};

/// Typed view over the [`Client`]'s server-level RPC namespace.
#[derive(Clone, Copy)]
pub struct ClientRpc<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpc<'a> {
    /// `account.*` sub-namespace.
    pub fn account(&self) -> ClientRpcAccount<'a> {
        ClientRpcAccount {
            client: self.client,
        }
    }

    /// `agentRegistry.*` sub-namespace.
    pub fn agent_registry(&self) -> ClientRpcAgentRegistry<'a> {
        ClientRpcAgentRegistry {
            client: self.client,
        }
    }

    /// `agents.*` sub-namespace.
    pub fn agents(&self) -> ClientRpcAgents<'a> {
        ClientRpcAgents {
            client: self.client,
        }
    }

    /// `catalog.*` sub-namespace.
    pub fn catalog(&self) -> ClientRpcCatalog<'a> {
        ClientRpcCatalog {
            client: self.client,
        }
    }

    /// `commands.*` sub-namespace.
    pub fn commands(&self) -> ClientRpcCommands<'a> {
        ClientRpcCommands {
            client: self.client,
        }
    }

    /// `extensions.*` sub-namespace.
    pub fn extensions(&self) -> ClientRpcExtensions<'a> {
        ClientRpcExtensions {
            client: self.client,
        }
    }

    /// `instructions.*` sub-namespace.
    pub fn instructions(&self) -> ClientRpcInstructions<'a> {
        ClientRpcInstructions {
            client: self.client,
        }
    }

    /// `llmInference.*` sub-namespace.
    pub fn llm_inference(&self) -> ClientRpcLlmInference<'a> {
        ClientRpcLlmInference {
            client: self.client,
        }
    }

    /// `managedSettings.*` sub-namespace.
    pub fn managed_settings(&self) -> ClientRpcManagedSettings<'a> {
        ClientRpcManagedSettings {
            client: self.client,
        }
    }

    /// `mcp.*` sub-namespace.
    pub fn mcp(&self) -> ClientRpcMcp<'a> {
        ClientRpcMcp {
            client: self.client,
        }
    }

    /// `models.*` sub-namespace.
    pub fn models(&self) -> ClientRpcModels<'a> {
        ClientRpcModels {
            client: self.client,
        }
    }

    /// `plugins.*` sub-namespace.
    pub fn plugins(&self) -> ClientRpcPlugins<'a> {
        ClientRpcPlugins {
            client: self.client,
        }
    }

    /// `runtime.*` sub-namespace.
    pub fn runtime(&self) -> ClientRpcRuntime<'a> {
        ClientRpcRuntime {
            client: self.client,
        }
    }

    /// `secrets.*` sub-namespace.
    pub fn secrets(&self) -> ClientRpcSecrets<'a> {
        ClientRpcSecrets {
            client: self.client,
        }
    }

    /// `sessionFs.*` sub-namespace.
    pub fn session_fs(&self) -> ClientRpcSessionFs<'a> {
        ClientRpcSessionFs {
            client: self.client,
        }
    }

    /// `sessions.*` sub-namespace.
    pub fn sessions(&self) -> ClientRpcSessions<'a> {
        ClientRpcSessions {
            client: self.client,
        }
    }

    /// `skills.*` sub-namespace.
    pub fn skills(&self) -> ClientRpcSkills<'a> {
        ClientRpcSkills {
            client: self.client,
        }
    }

    /// `tools.*` sub-namespace.
    pub fn tools(&self) -> ClientRpcTools<'a> {
        ClientRpcTools {
            client: self.client,
        }
    }

    /// `user.*` sub-namespace.
    pub fn user(&self) -> ClientRpcUser<'a> {
        ClientRpcUser {
            client: self.client,
        }
    }

    /// Checks server responsiveness and returns protocol information.
    ///
    /// Wire method: `ping`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional message to echo back to the caller.
    ///
    /// # Returns
    ///
    /// Server liveness response, including the echoed message, current server timestamp, and protocol version.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn ping(&self, params: PingRequest) -> Result<PingResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PING, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `connect`.
    ///
    /// # Parameters
    ///
    /// * `params` - Connection-level opt-ins for the `server.connect` handshake. Transport authentication is consumed by the native protocol boundary before dispatch.
    ///
    /// # Returns
    ///
    /// Handshake result reporting the server's protocol version and package version on success.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn connect(&self, params: ConnectRequest) -> Result<ConnectResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::CONNECT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers the calling SDK client as the per-entrypoint extension launch provider. Call before creating any sessions. When omitted, the runtime temporarily falls back to its built-in Node launcher for backward compatibility.
    ///
    /// Wire method: `registerExtensionLaunchProvider`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn register_extension_launch_provider(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(
                rpc_methods::REGISTEREXTENSIONLAUNCHPROVIDER,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }
}

/// `account.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcAccount<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcAccount<'a> {
    /// Gets Copilot quota usage for the current or opaquely selected authenticated user.
    ///
    /// Wire method: `account.getQuota`.
    ///
    /// # Returns
    ///
    /// Quota usage snapshots for the resolved user, keyed by quota type.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_quota(&self) -> Result<AccountGetQuotaResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::ACCOUNT_GETQUOTA, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets Copilot quota usage for the current or opaquely selected authenticated user.
    ///
    /// Wire method: `account.getQuota`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional opaque account selection or compatibility GitHub token used to look up quota.
    ///
    /// # Returns
    ///
    /// Quota usage snapshots for the resolved user, keyed by quota type.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_quota_with_params(
        &self,
        params: AccountGetQuotaRequest,
    ) -> Result<AccountGetQuotaResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::ACCOUNT_GETQUOTA, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets the currently active authentication credentials from the global auth manager.
    ///
    /// Wire method: `account.getCurrentAuth`.
    ///
    /// # Returns
    ///
    /// Current authentication state
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_current_auth(&self) -> Result<AccountGetCurrentAuthResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::ACCOUNT_GETCURRENTAUTH, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets all authenticated users available for account switching.
    ///
    /// Wire method: `account.getAllUsers`.
    ///
    /// # Returns
    ///
    /// List of all authenticated users
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_all_users(&self) -> Result<AccountGetAllUsersResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::ACCOUNT_GETALLUSERS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Stores authentication credentials after successful login (e.g., device code flow).
    ///
    /// Wire method: `account.login`.
    ///
    /// # Parameters
    ///
    /// * `params` - Credentials to store after successful authentication
    ///
    /// # Returns
    ///
    /// Result of a successful login; throws on failure
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn login(&self, params: AccountLoginRequest) -> Result<AccountLoginResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::ACCOUNT_LOGIN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Removes user authentication from keychain and persisted state.
    ///
    /// Wire method: `account.logout`.
    ///
    /// # Parameters
    ///
    /// * `params` - User to log out
    ///
    /// # Returns
    ///
    /// Logout result indicating if more users remain
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn logout(&self, params: AccountLogoutRequest) -> Result<AccountLogoutResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::ACCOUNT_LOGOUT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `agentRegistry.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcAgentRegistry<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcAgentRegistry<'a> {
    /// 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.
    ///
    /// Wire method: `agentRegistry.spawn`.
    ///
    /// # Parameters
    ///
    /// * `params` - Inputs to spawn a managed-server child via the controller's spawn delegate.
    ///
    /// # Returns
    ///
    /// Outcome of an agentRegistry.spawn call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn spawn(
        &self,
        params: AgentRegistrySpawnRequest,
    ) -> Result<AgentRegistrySpawnResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::AGENTREGISTRY_SPAWN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `agents.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcAgents<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcAgents<'a> {
    /// Discovers custom agents across user, project, plugin, and remote sources.
    ///
    /// Wire method: `agents.discover`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional project paths to include in agent discovery.
    ///
    /// # Returns
    ///
    /// Agents discovered across user, project, plugin, and remote sources.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn discover(&self, params: AgentsDiscoverRequest) -> Result<ServerAgentList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::AGENTS_DISCOVER, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `agents.getDiscoveryPaths`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional project paths to include when enumerating agent discovery directories.
    ///
    /// # Returns
    ///
    /// Canonical locations where custom agents can be created so the runtime will recognize them.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_discovery_paths(
        &self,
        params: AgentsGetDiscoveryPathsRequest,
    ) -> Result<AgentDiscoveryPathList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::AGENTS_GETDISCOVERYPATHS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `catalog.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcCatalog<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcCatalog<'a> {
    /// 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.
    ///
    /// Wire method: `catalog.search`.
    ///
    /// # Parameters
    ///
    /// * `params` - 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.
    ///
    /// # Returns
    ///
    /// Outcome of a catalog.search call: either bounded inert candidates, or one typed refusal. Never a partial success.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn search(&self, params: CatalogSearchRequest) -> Result<CatalogSearchResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::CATALOG_SEARCH, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `commands.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcCommands<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcCommands<'a> {
    /// 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.
    ///
    /// Wire method: `commands.list`.
    ///
    /// # Returns
    ///
    /// Slash commands available in the session, after applying any include/exclude filters.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<CommandList, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::COMMANDS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `extensions.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcExtensions<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcExtensions<'a> {
    /// Discovers user and enabled installed-plugin extensions from persisted Copilot home state, including enablement preferences. Launch-scoped additional plugins are not included.
    ///
    /// Wire method: `extensions.discover`.
    ///
    /// # Returns
    ///
    /// Extensions discovered from persisted Copilot home state and their effective loading mode. Launch-scoped additional plugins are not included.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn discover(&self) -> Result<DiscoveredExtensions, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::EXTENSIONS_DISCOVER, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Persistently enables extension IDs for future sessions. Active sessions are unchanged; use session.extensions.enable to update them.
    ///
    /// Wire method: `extensions.enable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Source-qualified extension identifiers to persistently enable for future sessions.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enable(&self, params: DiscoveredExtensionsEnableRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::EXTENSIONS_ENABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Persistently disables extension IDs for future sessions. Active sessions are unchanged; use session.extensions.disable to update them.
    ///
    /// Wire method: `extensions.disable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Source-qualified extension identifiers to persistently disable for future sessions.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn disable(&self, params: DiscoveredExtensionsDisableRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::EXTENSIONS_DISABLE, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `instructions.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcInstructions<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcInstructions<'a> {
    /// Discovers instruction sources across user, repository, and plugin sources.
    ///
    /// Wire method: `instructions.discover`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional project paths to include in instruction discovery.
    ///
    /// # Returns
    ///
    /// Instruction sources discovered across user, repository, and plugin sources.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn discover(
        &self,
        params: InstructionsDiscoverRequest,
    ) -> Result<ServerInstructionSourceList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::INSTRUCTIONS_DISCOVER, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `instructions.getDiscoveryPaths`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional project paths to include when enumerating instruction discovery targets.
    ///
    /// # Returns
    ///
    /// Canonical files and directories where custom instructions can be created so the runtime will recognize them.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_discovery_paths(
        &self,
        params: InstructionsGetDiscoveryPathsRequest,
    ) -> Result<InstructionDiscoveryPathList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::INSTRUCTIONS_GETDISCOVERYPATHS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `llmInference.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcLlmInference<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcLlmInference<'a> {
    /// Registers an SDK client as the LLM inference callback provider.
    ///
    /// Wire method: `llmInference.setProvider`.
    ///
    /// # Returns
    ///
    /// Indicates whether the calling client was registered as the LLM inference provider.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_provider(&self) -> Result<LlmInferenceSetProviderResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::LLMINFERENCE_SETPROVIDER, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `llmInference.httpResponseStart`.
    ///
    /// # Parameters
    ///
    /// * `params` - Response head.
    ///
    /// # Returns
    ///
    /// Whether the start frame was accepted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn http_response_start(
        &self,
        params: LlmInferenceHttpResponseStartRequest,
    ) -> Result<LlmInferenceHttpResponseStartResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::LLMINFERENCE_HTTPRESPONSESTART,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `llmInference.httpResponseChunk`.
    ///
    /// # Parameters
    ///
    /// * `params` - A response body chunk or terminal error.
    ///
    /// # Returns
    ///
    /// Whether the chunk was accepted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn http_response_chunk(
        &self,
        params: LlmInferenceHttpResponseChunkRequest,
    ) -> Result<LlmInferenceHttpResponseChunkResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::LLMINFERENCE_HTTPRESPONSECHUNK,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `managedSettings.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcManagedSettings<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcManagedSettings<'a> {
    /// 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.
    ///
    /// Wire method: `managedSettings.read`.
    ///
    /// # Returns
    ///
    /// Validated device-managed settings discovered before a session exists.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read(&self) -> Result<ManagedSettingsReadResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::MANAGEDSETTINGS_READ, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `mcp.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcMcp<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcMcp<'a> {
    /// `mcp.config.*` sub-namespace.
    pub fn config(&self) -> ClientRpcMcpConfig<'a> {
        ClientRpcMcpConfig {
            client: self.client,
        }
    }

    /// Discovers MCP servers from user, workspace, plugin, and builtin sources.
    ///
    /// Wire method: `mcp.discover`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional working directory used as context for MCP server discovery.
    ///
    /// # Returns
    ///
    /// MCP servers discovered from user, workspace, plugin, and built-in sources.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn discover(&self, params: McpDiscoverRequest) -> Result<McpDiscoverResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MCP_DISCOVER, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `mcp.planInstall`.
    ///
    /// # Parameters
    ///
    /// * `params` - A side-effect-free request for an MCP install plan. Computing a plan never writes configuration, stores a secret, or reloads MCP servers.
    ///
    /// # Returns
    ///
    /// Outcome of an mcp.planInstall call: either a normalised plan, or one typed refusal. Nothing is written in either case.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn plan_install(
        &self,
        params: McpPlanInstallRequest,
    ) -> Result<McpPlanInstallResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MCP_PLANINSTALL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `mcp.config.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcMcpConfig<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcMcpConfig<'a> {
    /// Lists MCP servers from user configuration.
    ///
    /// Wire method: `mcp.config.list`.
    ///
    /// # Returns
    ///
    /// User-configured MCP servers, keyed by server name.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<McpConfigList, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::MCP_CONFIG_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Adds an MCP server to user configuration.
    ///
    /// Wire method: `mcp.config.add`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server name and configuration to add to user configuration.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add(&self, params: McpConfigAddRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MCP_CONFIG_ADD, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Updates an MCP server in user configuration.
    ///
    /// Wire method: `mcp.config.update`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server name and replacement configuration to write to user configuration.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update(&self, params: McpConfigUpdateRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MCP_CONFIG_UPDATE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Removes an MCP server from user configuration.
    ///
    /// Wire method: `mcp.config.remove`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server name to remove from user configuration.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn remove(&self, params: McpConfigRemoveRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MCP_CONFIG_REMOVE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Enables MCP servers in user configuration for new sessions.
    ///
    /// Wire method: `mcp.config.enable`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server names to enable for new sessions.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enable(&self, params: McpConfigEnableRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MCP_CONFIG_ENABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Disables MCP servers in user configuration for new sessions.
    ///
    /// Wire method: `mcp.config.disable`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server names to disable for new sessions.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn disable(&self, params: McpConfigDisableRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MCP_CONFIG_DISABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Drops this runtime process's in-memory MCP server-definition cache so the next MCP config read observes disk.
    ///
    /// Wire method: `mcp.config.reload`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::MCP_CONFIG_RELOAD, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `models.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcModels<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcModels<'a> {
    /// Lists Copilot models available to the authenticated user.
    ///
    /// Wire method: `models.list`.
    ///
    /// # Returns
    ///
    /// List of Copilot models available to the resolved user, including capabilities and billing metadata.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<ModelList, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::MODELS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists Copilot models available to the authenticated user.
    ///
    /// Wire method: `models.list`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional opaque account selection or compatibility GitHub token used to list models.
    ///
    /// # Returns
    ///
    /// List of Copilot models available to the resolved user, including capabilities and billing metadata.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_with_params(&self, params: ModelsListRequest) -> Result<ModelList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::MODELS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the running runtime's complete catalog of well-known built-in model IDs without authentication or network access.
    ///
    /// Wire method: `models.getBuiltInCatalog`.
    ///
    /// # Returns
    ///
    /// The running runtime's complete catalog of well-known built-in model IDs, including supported models and additional IDs with built-in metadata.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_built_in_catalog(&self) -> Result<BuiltInModelCatalog, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::MODELS_GETBUILTINCATALOG, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `plugins.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcPlugins<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcPlugins<'a> {
    /// `plugins.builtin.*` sub-namespace.
    pub fn builtin(&self) -> ClientRpcPluginsBuiltin<'a> {
        ClientRpcPluginsBuiltin {
            client: self.client,
        }
    }

    /// `plugins.marketplaces.*` sub-namespace.
    pub fn marketplaces(&self) -> ClientRpcPluginsMarketplaces<'a> {
        ClientRpcPluginsMarketplaces {
            client: self.client,
        }
    }

    /// Lists plugins installed in user/global state.
    ///
    /// Wire method: `plugins.list`.
    ///
    /// # Returns
    ///
    /// Plugins installed in user/global state.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<PluginListResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Installs a plugin from a marketplace, GitHub repo, URL, or local path.
    ///
    /// Wire method: `plugins.install`.
    ///
    /// # Parameters
    ///
    /// * `params` - Plugin source and optional working directory for relative-path resolution.
    ///
    /// # Returns
    ///
    /// Result of installing a plugin.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn install(
        &self,
        params: PluginsInstallRequest,
    ) -> Result<PluginInstallResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_INSTALL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Uninstalls an installed plugin.
    ///
    /// Wire method: `plugins.uninstall`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name (or spec) of the plugin to uninstall.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn uninstall(&self, params: PluginsUninstallRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_UNINSTALL, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Updates an installed plugin to its latest published version.
    ///
    /// Wire method: `plugins.update`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name (or spec) of the plugin to update.
    ///
    /// # Returns
    ///
    /// Result of updating a single plugin.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update(&self, params: PluginsUpdateRequest) -> Result<PluginUpdateResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_UPDATE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Updates every installed plugin to its latest published version.
    ///
    /// Wire method: `plugins.updateAll`.
    ///
    /// # Returns
    ///
    /// Result of updating all installed plugins.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update_all(&self) -> Result<PluginUpdateAllResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_UPDATEALL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enables installed plugins for new sessions.
    ///
    /// Wire method: `plugins.enable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Plugin names (or specs) to enable.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enable(&self, params: PluginsEnableRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_ENABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Disables installed plugins for new sessions.
    ///
    /// Wire method: `plugins.disable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Plugin names (or specs) to disable.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn disable(&self, params: PluginsDisableRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_DISABLE, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `plugins.builtin.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcPluginsBuiltin<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcPluginsBuiltin<'a> {
    /// Replaces this server's trusted built-in plugin directories while no sessions are active.
    ///
    /// Wire method: `plugins.builtin.set`.
    ///
    /// # Parameters
    ///
    /// * `params` - Trusted built-in plugin directories to use for this runtime process.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set(&self, params: PluginsBuiltinSetRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_BUILTIN_SET, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `plugins.marketplaces.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcPluginsMarketplaces<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcPluginsMarketplaces<'a> {
    /// Lists all registered marketplaces (defaults + user-added).
    ///
    /// Wire method: `plugins.marketplaces.list`.
    ///
    /// # Returns
    ///
    /// All registered marketplaces, including built-in defaults.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<MarketplaceListResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_MARKETPLACES_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers a new marketplace from a source (owner/repo, URL, or local path).
    ///
    /// Wire method: `plugins.marketplaces.add`.
    ///
    /// # Parameters
    ///
    /// * `params` - Marketplace source and optional working directory for relative-path resolution.
    ///
    /// # Returns
    ///
    /// Result of registering a new marketplace.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add(
        &self,
        params: PluginsMarketplacesAddRequest,
    ) -> Result<MarketplaceAddResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_MARKETPLACES_ADD, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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`.
    ///
    /// Wire method: `plugins.marketplaces.remove`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name of the marketplace to remove and an optional force flag.
    ///
    /// # Returns
    ///
    /// Outcome of the remove attempt, including dependent-plugin info when applicable.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn remove(
        &self,
        params: PluginsMarketplacesRemoveRequest,
    ) -> Result<MarketplaceRemoveResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_MARKETPLACES_REMOVE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists plugins advertised by a registered marketplace.
    ///
    /// Wire method: `plugins.marketplaces.browse`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name of the marketplace whose plugin catalog to fetch.
    ///
    /// # Returns
    ///
    /// Plugins advertised by the marketplace.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn browse(
        &self,
        params: PluginsMarketplacesBrowseRequest,
    ) -> Result<MarketplaceBrowseResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_MARKETPLACES_BROWSE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Re-fetches one or all registered marketplace catalogs.
    ///
    /// Wire method: `plugins.marketplaces.refresh`.
    ///
    /// # Returns
    ///
    /// Result of refreshing one or more marketplace catalogs.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn refresh(&self) -> Result<MarketplaceRefreshResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_MARKETPLACES_REFRESH, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Re-fetches one or all registered marketplace catalogs.
    ///
    /// Wire method: `plugins.marketplaces.refresh`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional marketplace name; omit to refresh all.
    ///
    /// # Returns
    ///
    /// Result of refreshing one or more marketplace catalogs.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn refresh_with_params(
        &self,
        params: PluginsMarketplacesRefreshRequest,
    ) -> Result<MarketplaceRefreshResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::PLUGINS_MARKETPLACES_REFRESH, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `runtime.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcRuntime<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcRuntime<'a> {
    /// Gracefully shuts down an SDK-owned runtime. The response is sent only after cleanup completes; callers may then terminate the owned runtime process.
    ///
    /// Wire method: `runtime.shutdown`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn shutdown(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::RUNTIME_SHUTDOWN, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `secrets.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcSecrets<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcSecrets<'a> {
    /// Registers secret values for redaction in session logs and exports. The SDK calls this to inject dynamically generated secret values (e.g., OIDC tokens).
    ///
    /// Wire method: `secrets.addFilterValues`.
    ///
    /// # Parameters
    ///
    /// * `params` - Secret values to add to the redaction filter.
    ///
    /// # Returns
    ///
    /// Confirmation that the secret values were registered.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add_filter_values(
        &self,
        params: SecretsAddFilterValuesRequest,
    ) -> Result<SecretsAddFilterValuesResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SECRETS_ADDFILTERVALUES, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `sessionFs.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcSessionFs<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcSessionFs<'a> {
    /// Registers an SDK client as the session filesystem provider.
    ///
    /// Wire method: `sessionFs.setProvider`.
    ///
    /// # Parameters
    ///
    /// * `params` - Initial working directory, session-state path layout, and path conventions used to register the calling SDK client as the session filesystem provider.
    ///
    /// # Returns
    ///
    /// Indicates whether the calling client was registered as the session filesystem provider.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_provider(
        &self,
        params: SessionFsSetProviderRequest,
    ) -> Result<SessionFsSetProviderResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONFS_SETPROVIDER, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `sessions.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcSessions<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcSessions<'a> {
    /// Creates or resumes a local session and returns the opened session ID.
    ///
    /// Wire method: `sessions.open`.
    ///
    /// # Returns
    ///
    /// Result of opening a session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn open(&self) -> Result<SessionOpenResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_OPEN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Creates a new session by forking persisted history from an existing session.
    ///
    /// Wire method: `sessions.fork`.
    ///
    /// # Parameters
    ///
    /// * `params` - Source session identifier to fork from, optional event-ID boundary, and optional friendly name for the new session.
    ///
    /// # Returns
    ///
    /// Identifier and optional friendly name assigned to the newly forked session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn fork(&self, params: SessionsForkRequest) -> Result<SessionsForkResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_FORK, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Connects to an existing remote session and exposes it as an SDK session.
    ///
    /// Wire method: `sessions.connect`.
    ///
    /// # Parameters
    ///
    /// * `params` - Remote session connection parameters.
    ///
    /// # Returns
    ///
    /// Remote session connection result.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn connect(
        &self,
        params: ConnectRemoteSessionParams,
    ) -> Result<RemoteSessionConnectionResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_CONNECT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.).
    ///
    /// Wire method: `sessions.list`.
    ///
    /// # Returns
    ///
    /// Sessions matching the filter, ordered most-recently-modified first.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<SessionList, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.).
    ///
    /// Wire method: `sessions.list`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional source filter, metadata-load limit, and context filter applied to the returned sessions.
    ///
    /// # Returns
    ///
    /// Sessions matching the filter, ordered most-recently-modified first.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_with_params(
        &self,
        params: SessionsListRequest,
    ) -> Result<SessionList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reads lightweight persisted metadata for one local session without opening it.
    ///
    /// Wire method: `sessions.getMetadata`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID whose persisted metadata should be read.
    ///
    /// # Returns
    ///
    /// Persisted local session metadata when the session exists.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn get_metadata(
        &self,
        params: SessionsGetMetadataRequest,
    ) -> Result<SessionsGetMetadataResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_GETMETADATA, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists recent local session IDs that contain user-visible history, omitting housekeeping-only sessions.
    ///
    /// Wire method: `sessions.listNonEmptySessionIds`.
    ///
    /// # Parameters
    ///
    /// * `params` - Limit for non-empty local session IDs.
    ///
    /// # Returns
    ///
    /// Recent local session IDs that contain user-visible history.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn list_non_empty_session_ids(
        &self,
        params: SessionsListNonEmptySessionIdsRequest,
    ) -> Result<SessionsListNonEmptySessionIdsResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_LISTNONEMPTYSESSIONIDS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Finds the local session bound to a GitHub task ID, if any.
    ///
    /// Wire method: `sessions.findByTaskId`.
    ///
    /// # Parameters
    ///
    /// * `params` - GitHub task ID to look up.
    ///
    /// # Returns
    ///
    /// ID of the local session bound to the given GitHub task, or omitted when none.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn find_by_task_id(
        &self,
        params: SessionsFindByTaskIDRequest,
    ) -> Result<SessionsFindByTaskIDResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_FINDBYTASKID, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves a UUID prefix to a unique session ID, if exactly one session matches.
    ///
    /// Wire method: `sessions.findByPrefix`.
    ///
    /// # Parameters
    ///
    /// * `params` - UUID prefix to resolve to a unique session ID.
    ///
    /// # Returns
    ///
    /// Session ID matching the prefix, omitted when no unique match exists.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn find_by_prefix(
        &self,
        params: SessionsFindByPrefixRequest,
    ) -> Result<SessionsFindByPrefixResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_FINDBYPREFIX, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the most-relevant prior session for a given working-directory context.
    ///
    /// Wire method: `sessions.getLastForContext`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional working-directory context used to score session relevance.
    ///
    /// # Returns
    ///
    /// Most-relevant session ID for the supplied context, or omitted when no sessions exist.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_last_for_context(
        &self,
        params: SessionsGetLastForContextRequest,
    ) -> Result<SessionsGetLastForContextResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_GETLASTFORCONTEXT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.getEventFilePath`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID whose event-log file path to compute.
    ///
    /// # Returns
    ///
    /// Absolute path to the session's events.jsonl file on disk.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn get_event_file_path(
        &self,
        params: SessionsGetEventFilePathRequest,
    ) -> Result<SessionsGetEventFilePathResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_GETEVENTFILEPATH, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the on-disk byte size of each session's workspace directory.
    ///
    /// Wire method: `sessions.getSizes`.
    ///
    /// # Returns
    ///
    /// Map of sessionId -> on-disk size in bytes for each session's workspace directory.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_sizes(&self) -> Result<SessionSizes, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_GETSIZES, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the subset of the supplied session IDs that are currently held by another running process.
    ///
    /// Wire method: `sessions.checkInUse`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session IDs to test for live in-use locks.
    ///
    /// # Returns
    ///
    /// Session IDs from the input set that are currently in use by another process.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn check_in_use(
        &self,
        params: SessionsCheckInUseRequest,
    ) -> Result<SessionsCheckInUseResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_CHECKINUSE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.getPersistedRemoteSteerable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID to look up the persisted remote-steerable flag for.
    ///
    /// # Returns
    ///
    /// The session's persisted remote-steerable flag, or omitted when no value has been persisted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn get_persisted_remote_steerable(
        &self,
        params: SessionsGetPersistedRemoteSteerableRequest,
    ) -> Result<SessionsGetPersistedRemoteSteerableResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_GETPERSISTEDREMOTESTEERABLE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Closes a session: emits shutdown, flushes pending events, releases the in-use lock, and disposes the active session.
    ///
    /// Wire method: `sessions.close`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID to close.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn close(&self, params: SessionsCloseRequest) -> Result<SessionsCloseResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_CLOSE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Closes, deactivates, and deletes a set of sessions, returning the bytes freed per session.
    ///
    /// Wire method: `sessions.bulkDelete`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session IDs to close, deactivate, and delete from disk.
    ///
    /// # Returns
    ///
    /// Map of sessionId -> bytes freed by removing the session's workspace directory.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn bulk_delete(
        &self,
        params: SessionsBulkDeleteRequest,
    ) -> Result<SessionBulkDeleteResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_BULKDELETE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Deletes one local session from disk after running the same lifecycle hooks as the session manager.
    ///
    /// Wire method: `sessions.delete`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID to delete from disk.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn delete(&self, params: SessionsDeleteRequest) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_DELETE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Deletes sessions older than the given threshold, with optional dry-run and exclusion list.
    ///
    /// Wire method: `sessions.pruneOld`.
    ///
    /// # Parameters
    ///
    /// * `params` - Age threshold and optional flags controlling which old sessions are pruned (or simulated when dryRun is true).
    ///
    /// # Returns
    ///
    /// Outcome of the prune operation: deleted IDs, dry-run candidates, skipped IDs, total bytes freed, and the dry-run flag.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn prune_old(
        &self,
        params: SessionsPruneOldRequest,
    ) -> Result<SessionPruneResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_PRUNEOLD, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Flushes a session's pending events to disk.
    ///
    /// Wire method: `sessions.save`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID whose pending events should be flushed to disk.
    ///
    /// # Returns
    ///
    /// Flush a session's pending events to disk. No-op when no writer exists for the session (e.g., already closed).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn save(&self, params: SessionsSaveRequest) -> Result<SessionsSaveResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_SAVE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Releases the in-use lock held by this process for a session.
    ///
    /// Wire method: `sessions.releaseLock`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID whose in-use lock should be released.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn release_lock(
        &self,
        params: SessionsReleaseLockRequest,
    ) -> Result<SessionsReleaseLockResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_RELEASELOCK, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Backfills missing summary and context fields on the supplied session metadata records.
    ///
    /// Wire method: `sessions.enrichMetadata`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session metadata records to enrich with summary and context information.
    ///
    /// # Returns
    ///
    /// The enriched metadata records, with summary and context fields backfilled where available. Sessions confirmed empty and unnamed are omitted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enrich_metadata(
        &self,
        params: SessionsEnrichMetadataRequest,
    ) -> Result<SessionEnrichMetadataResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_ENRICHMETADATA, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reloads user, plugin, and (optionally) repo hooks on the active session.
    ///
    /// Wire method: `sessions.reloadPluginHooks`.
    ///
    /// # Parameters
    ///
    /// * `params` - Active session ID and an optional flag for deferring repo-level hooks until folder trust.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload_plugin_hooks(
        &self,
        params: SessionsReloadPluginHooksRequest,
    ) -> Result<SessionsReloadPluginHooksResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_RELOADPLUGINHOOKS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Loads previously-deferred repo-level hooks on the active session, returning queued startup prompts.
    ///
    /// Wire method: `sessions.loadDeferredRepoHooks`.
    ///
    /// # Parameters
    ///
    /// * `params` - Active session ID whose deferred repo-level hooks should be loaded.
    ///
    /// # Returns
    ///
    /// Queued repo-level startup prompts and the total hook command count after loading.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn load_deferred_repo_hooks(
        &self,
        params: SessionsLoadDeferredRepoHooksRequest,
    ) -> Result<SessionLoadDeferredRepoHooksResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_LOADDEFERREDREPOHOOKS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Replaces the manager-wide additional plugins registered with the session manager.
    ///
    /// Wire method: `sessions.setAdditionalPlugins`.
    ///
    /// # Parameters
    ///
    /// * `params` - Manager-wide additional plugins to register; replaces any previously-configured set.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_additional_plugins(
        &self,
        params: SessionsSetAdditionalPluginsRequest,
    ) -> Result<SessionsSetAdditionalPluginsResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_SETADDITIONALPLUGINS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.getBoardEntryCount`.
    ///
    /// # Parameters
    ///
    /// * `params` - Session ID whose board entry count should be returned.
    ///
    /// # Returns
    ///
    /// Dynamic-context board entry count, when available.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn get_board_entry_count(
        &self,
        params: SessionsGetBoardEntryCountRequest,
    ) -> Result<SessionsGetBoardEntryCountResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_GETBOARDENTRYCOUNT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.startRemoteControl`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for attaching the remote-control singleton to a session.
    ///
    /// # Returns
    ///
    /// Wrapper for the singleton's current status.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn start_remote_control(
        &self,
        params: SessionsStartRemoteControlRequest,
    ) -> Result<RemoteControlStatusResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_STARTREMOTECONTROL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.transferRemoteControl`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for atomically rebinding the remote-control singleton.
    ///
    /// # Returns
    ///
    /// Outcome of a transferRemoteControl call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn transfer_remote_control(
        &self,
        params: SessionsTransferRemoteControlRequest,
    ) -> Result<RemoteControlTransferResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_TRANSFERREMOTECONTROL,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.setRemoteControlSteering`.
    ///
    /// # Parameters
    ///
    /// * `params` - Patch for the singleton's steering state.
    ///
    /// # Returns
    ///
    /// Wrapper for the singleton's current status.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_remote_control_steering(
        &self,
        params: SessionsSetRemoteControlSteeringRequest,
    ) -> Result<RemoteControlStatusResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_SETREMOTECONTROLSTEERING,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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).
    ///
    /// Wire method: `sessions.stopRemoteControl`.
    ///
    /// # Returns
    ///
    /// Outcome of a stopRemoteControl call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn stop_remote_control(&self) -> Result<RemoteControlStopResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_STOPREMOTECONTROL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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).
    ///
    /// Wire method: `sessions.stopRemoteControl`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for stopping the remote-control singleton.
    ///
    /// # Returns
    ///
    /// Outcome of a stopRemoteControl call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn stop_remote_control_with_params(
        &self,
        params: SessionsStopRemoteControlRequest,
    ) -> Result<RemoteControlStopResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SESSIONS_STOPREMOTECONTROL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the current state of the remote-control singleton, including the attached session id and frontend URL when active.
    ///
    /// Wire method: `sessions.getRemoteControlStatus`.
    ///
    /// # Returns
    ///
    /// Wrapper for the singleton's current status.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_remote_control_status(&self) -> Result<RemoteControlStatusResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_GETREMOTECONTROLSTATUS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.registerExtensionToolsOnSession`.
    ///
    /// # Parameters
    ///
    /// * `params` - Params to attach an extension loader's tools to a session.
    ///
    /// # Returns
    ///
    /// Handle for releasing the extension tool registration.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn register_extension_tools_on_session(
        &self,
        params: RegisterExtensionToolsParams,
    ) -> Result<RegisterExtensionToolsResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_REGISTEREXTENSIONTOOLSONSESSION,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `sessions.configureSessionExtensions`.
    ///
    /// # Parameters
    ///
    /// * `params` - Params to attach or detach an in-process ExtensionController delegate.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn configure_session_extensions(
        &self,
        params: ConfigureSessionExtensionsParams,
    ) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SESSIONS_CONFIGURESESSIONEXTENSIONS,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }
}

/// `skills.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcSkills<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcSkills<'a> {
    /// `skills.config.*` sub-namespace.
    pub fn config(&self) -> ClientRpcSkillsConfig<'a> {
        ClientRpcSkillsConfig {
            client: self.client,
        }
    }

    /// Discovers skills across global and project sources.
    ///
    /// Wire method: `skills.discover`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional project paths and additional skill directories to include in discovery.
    ///
    /// # Returns
    ///
    /// Skills discovered across global and project sources.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn discover(&self, params: SkillsDiscoverRequest) -> Result<ServerSkillList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SKILLS_DISCOVER, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `skills.getDiscoveryPaths`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional project paths to enumerate.
    ///
    /// # Returns
    ///
    /// Canonical locations where skills can be created so the runtime will recognize them.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_discovery_paths(
        &self,
        params: SkillsGetDiscoveryPathsRequest,
    ) -> Result<SkillDiscoveryPathList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::SKILLS_GETDISCOVERYPATHS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `skills.config.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcSkillsConfig<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcSkillsConfig<'a> {
    /// Replaces the global list of disabled skills.
    ///
    /// Wire method: `skills.config.setDisabledSkills`.
    ///
    /// # Parameters
    ///
    /// * `params` - Skill names to mark as disabled in global configuration, replacing any previous list.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_disabled_skills(
        &self,
        params: SkillsConfigSetDisabledSkillsRequest,
    ) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SKILLS_CONFIG_SETDISABLEDSKILLS,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Atomically adds or removes one skill from the disabled list.
    ///
    /// Wire method: `skills.config.setSkillDisabled`.
    ///
    /// # Parameters
    ///
    /// * `params` - Adds or removes a single skill from the global disabled list, leaving every other entry untouched.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_skill_disabled(
        &self,
        params: SkillsConfigSetSkillDisabledRequest,
    ) -> Result<(), Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(
                rpc_methods::SKILLS_CONFIG_SETSKILLDISABLED,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }
}

/// `tools.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcTools<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcTools<'a> {
    /// Lists built-in tools available for a model.
    ///
    /// Wire method: `tools.list`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional model identifier whose tool overrides should be applied to the listing.
    ///
    /// # Returns
    ///
    /// Built-in tools available for the requested model, with their parameters and instructions.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self, params: ToolsListRequest) -> Result<ToolList, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::TOOLS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `user.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcUser<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcUser<'a> {
    /// `user.settings.*` sub-namespace.
    pub fn settings(&self) -> ClientRpcUserSettings<'a> {
        ClientRpcUserSettings {
            client: self.client,
        }
    }
}

/// `user.settings.*` RPCs.
#[derive(Clone, Copy)]
pub struct ClientRpcUserSettings<'a> {
    pub(crate) client: &'a Client,
}

impl<'a> ClientRpcUserSettings<'a> {
    /// Drops this runtime process's in-memory user settings cache so the next settings read observes disk.
    ///
    /// Wire method: `user.settings.reload`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::USER_SETTINGS_RELOAD, Some(wire_params))
            .await?;
        Ok(())
    }

    /// 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.
    ///
    /// Wire method: `user.settings.get`.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get(&self) -> Result<UserSettingsGetResult, Error> {
        let wire_params = serde_json::json!({});
        let _value = self
            .client
            .call(rpc_methods::USER_SETTINGS_GET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `user.settings.set`.
    ///
    /// # Parameters
    ///
    /// * `params` - 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.
    ///
    /// # Returns
    ///
    /// Outcome of writing user settings.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set(
        &self,
        params: UserSettingsSetRequest,
    ) -> Result<UserSettingsSetResult, Error> {
        let wire_params = serde_json::to_value(params)?;
        let _value = self
            .client
            .call(rpc_methods::USER_SETTINGS_SET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// Typed view over a [`Session`]'s RPC namespace.
#[derive(Clone, Copy)]
pub struct SessionRpc<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpc<'a> {
    /// `session.agent.*` sub-namespace.
    pub fn agent(&self) -> SessionRpcAgent<'a> {
        SessionRpcAgent {
            session: self.session,
        }
    }

    /// `session.canvas.*` sub-namespace.
    pub fn canvas(&self) -> SessionRpcCanvas<'a> {
        SessionRpcCanvas {
            session: self.session,
        }
    }

    /// `session.commands.*` sub-namespace.
    pub fn commands(&self) -> SessionRpcCommands<'a> {
        SessionRpcCommands {
            session: self.session,
        }
    }

    /// `session.completions.*` sub-namespace.
    pub fn completions(&self) -> SessionRpcCompletions<'a> {
        SessionRpcCompletions {
            session: self.session,
        }
    }

    /// `session.contentExclusion.*` sub-namespace.
    pub fn content_exclusion(&self) -> SessionRpcContentExclusion<'a> {
        SessionRpcContentExclusion {
            session: self.session,
        }
    }

    /// `session.debug.*` sub-namespace.
    pub fn debug(&self) -> SessionRpcDebug<'a> {
        SessionRpcDebug {
            session: self.session,
        }
    }

    /// `session.eventLog.*` sub-namespace.
    pub fn event_log(&self) -> SessionRpcEventLog<'a> {
        SessionRpcEventLog {
            session: self.session,
        }
    }

    /// `session.extensions.*` sub-namespace.
    pub fn extensions(&self) -> SessionRpcExtensions<'a> {
        SessionRpcExtensions {
            session: self.session,
        }
    }

    /// `session.factory.*` sub-namespace.
    pub fn factory(&self) -> SessionRpcFactory<'a> {
        SessionRpcFactory {
            session: self.session,
        }
    }

    /// `session.fleet.*` sub-namespace.
    pub fn fleet(&self) -> SessionRpcFleet<'a> {
        SessionRpcFleet {
            session: self.session,
        }
    }

    /// `session.gitHubAuth.*` sub-namespace.
    pub fn git_hub_auth(&self) -> SessionRpcGitHubAuth<'a> {
        SessionRpcGitHubAuth {
            session: self.session,
        }
    }

    /// `session.history.*` sub-namespace.
    pub fn history(&self) -> SessionRpcHistory<'a> {
        SessionRpcHistory {
            session: self.session,
        }
    }

    /// `session.instructions.*` sub-namespace.
    pub fn instructions(&self) -> SessionRpcInstructions<'a> {
        SessionRpcInstructions {
            session: self.session,
        }
    }

    /// `session.limitPrediction.*` sub-namespace.
    pub fn limit_prediction(&self) -> SessionRpcLimitPrediction<'a> {
        SessionRpcLimitPrediction {
            session: self.session,
        }
    }

    /// `session.lsp.*` sub-namespace.
    pub fn lsp(&self) -> SessionRpcLsp<'a> {
        SessionRpcLsp {
            session: self.session,
        }
    }

    /// `session.mcp.*` sub-namespace.
    pub fn mcp(&self) -> SessionRpcMcp<'a> {
        SessionRpcMcp {
            session: self.session,
        }
    }

    /// `session.metadata.*` sub-namespace.
    pub fn metadata(&self) -> SessionRpcMetadata<'a> {
        SessionRpcMetadata {
            session: self.session,
        }
    }

    /// `session.mode.*` sub-namespace.
    pub fn mode(&self) -> SessionRpcMode<'a> {
        SessionRpcMode {
            session: self.session,
        }
    }

    /// `session.model.*` sub-namespace.
    pub fn model(&self) -> SessionRpcModel<'a> {
        SessionRpcModel {
            session: self.session,
        }
    }

    /// `session.name.*` sub-namespace.
    pub fn name(&self) -> SessionRpcName<'a> {
        SessionRpcName {
            session: self.session,
        }
    }

    /// `session.options.*` sub-namespace.
    pub fn options(&self) -> SessionRpcOptions<'a> {
        SessionRpcOptions {
            session: self.session,
        }
    }

    /// `session.permissions.*` sub-namespace.
    pub fn permissions(&self) -> SessionRpcPermissions<'a> {
        SessionRpcPermissions {
            session: self.session,
        }
    }

    /// `session.plan.*` sub-namespace.
    pub fn plan(&self) -> SessionRpcPlan<'a> {
        SessionRpcPlan {
            session: self.session,
        }
    }

    /// `session.plugins.*` sub-namespace.
    pub fn plugins(&self) -> SessionRpcPlugins<'a> {
        SessionRpcPlugins {
            session: self.session,
        }
    }

    /// `session.provider.*` sub-namespace.
    pub fn provider(&self) -> SessionRpcProvider<'a> {
        SessionRpcProvider {
            session: self.session,
        }
    }

    /// `session.queue.*` sub-namespace.
    pub fn queue(&self) -> SessionRpcQueue<'a> {
        SessionRpcQueue {
            session: self.session,
        }
    }

    /// `session.remote.*` sub-namespace.
    pub fn remote(&self) -> SessionRpcRemote<'a> {
        SessionRpcRemote {
            session: self.session,
        }
    }

    /// `session.schedule.*` sub-namespace.
    pub fn schedule(&self) -> SessionRpcSchedule<'a> {
        SessionRpcSchedule {
            session: self.session,
        }
    }

    /// `session.settings.*` sub-namespace.
    pub fn settings(&self) -> SessionRpcSettings<'a> {
        SessionRpcSettings {
            session: self.session,
        }
    }

    /// `session.shell.*` sub-namespace.
    pub fn shell(&self) -> SessionRpcShell<'a> {
        SessionRpcShell {
            session: self.session,
        }
    }

    /// `session.skills.*` sub-namespace.
    pub fn skills(&self) -> SessionRpcSkills<'a> {
        SessionRpcSkills {
            session: self.session,
        }
    }

    /// `session.tasks.*` sub-namespace.
    pub fn tasks(&self) -> SessionRpcTasks<'a> {
        SessionRpcTasks {
            session: self.session,
        }
    }

    /// `session.telemetry.*` sub-namespace.
    pub fn telemetry(&self) -> SessionRpcTelemetry<'a> {
        SessionRpcTelemetry {
            session: self.session,
        }
    }

    /// `session.tools.*` sub-namespace.
    pub fn tools(&self) -> SessionRpcTools<'a> {
        SessionRpcTools {
            session: self.session,
        }
    }

    /// `session.ui.*` sub-namespace.
    pub fn ui(&self) -> SessionRpcUi<'a> {
        SessionRpcUi {
            session: self.session,
        }
    }

    /// `session.usage.*` sub-namespace.
    pub fn usage(&self) -> SessionRpcUsage<'a> {
        SessionRpcUsage {
            session: self.session,
        }
    }

    /// `session.visibility.*` sub-namespace.
    pub fn visibility(&self) -> SessionRpcVisibility<'a> {
        SessionRpcVisibility {
            session: self.session,
        }
    }

    /// `session.workspaces.*` sub-namespace.
    pub fn workspaces(&self) -> SessionRpcWorkspaces<'a> {
        SessionRpcWorkspaces {
            session: self.session,
        }
    }

    /// Suspends the session while preserving persisted state for later resume.
    ///
    /// Wire method: `session.suspend`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn suspend(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SUSPEND, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Sends a user message to the session and returns its message ID.
    ///
    /// Wire method: `session.send`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for sending a user message to the session
    ///
    /// # Returns
    ///
    /// Result of sending a user message
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn send(&self, params: SendRequest) -> Result<SendResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SEND, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.sendMessages`.
    ///
    /// # Parameters
    ///
    /// * `params` - 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.
    ///
    /// # Returns
    ///
    /// Result of sending zero or more user messages
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn send_messages(
        &self,
        params: SendMessagesRequest,
    ) -> Result<SendMessagesResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SENDMESSAGES, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Queues or sends an internal system notification to the session according to its passive policy.
    ///
    /// Wire method: `session.sendSystemNotification`.
    ///
    /// # Parameters
    ///
    /// * `params` - Internal request for sending a system notification.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn send_system_notification(
        &self,
        params: SendSystemNotificationRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_SENDSYSTEMNOTIFICATION,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Aborts the current agent turn.
    ///
    /// Wire method: `session.abort`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for aborting the current turn
    ///
    /// # Returns
    ///
    /// Result of aborting the current turn
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn abort(&self, params: AbortRequest) -> Result<AbortResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_ABORT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.interruptMainTurn`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for interrupting the main agent turn.
    ///
    /// # Returns
    ///
    /// Result of interrupting the main agent turn.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn interrupt_main_turn(
        &self,
        params: InterruptMainTurnRequest,
    ) -> Result<InterruptMainTurnResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_INTERRUPTMAINTURN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Cancels every running background agent (task-registry subagents plus sidekick agents) without interrupting the main agent loop. Promoted attached shells are left running.
    ///
    /// Wire method: `session.cancelAllBackgroundAgents`.
    ///
    /// # Returns
    ///
    /// The number of running background agents (task-registry agents) that were cancelled.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn cancel_all_background_agents(
        &self,
    ) -> Result<SessionCancelAllBackgroundAgentsResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_CANCELALLBACKGROUNDAGENTS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.shutdown`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for shutting down the session
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn shutdown(&self, params: ShutdownRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SHUTDOWN, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Emits a user-visible session log event.
    ///
    /// Wire method: `session.log`.
    ///
    /// # Parameters
    ///
    /// * `params` - Message text, optional severity level, persistence flag, optional follow-up URL, and optional tip.
    ///
    /// # Returns
    ///
    /// Identifier of the session event that was emitted for the log message.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn log(&self, params: LogRequest) -> Result<LogResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_LOG, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.agent.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcAgent<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcAgent<'a> {
    /// Lists agents available to the session. Defaults to custom agents only; pass includeBuiltInAgents to include the effective built-in agents.
    ///
    /// Wire method: `session.agent.list`.
    ///
    /// # Returns
    ///
    /// Agents available to the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<AgentList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_AGENT_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists agents available to the session. Defaults to custom agents only; pass includeBuiltInAgents to include the effective built-in agents.
    ///
    /// Wire method: `session.agent.list`.
    ///
    /// # Parameters
    ///
    /// * `params` - Controls whether built-in agents and authored prompt text are included.
    ///
    /// # Returns
    ///
    /// Agents available to the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_with_params(&self, params: AgentListRequest) -> Result<AgentList, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_AGENT_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.agent.setPrompt`.
    ///
    /// # Parameters
    ///
    /// * `params` - An in-memory authored prompt override for an available agent.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_prompt(&self, params: AgentSetPromptRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_AGENT_SETPROMPT, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Gets the currently selected custom agent for the session.
    ///
    /// Wire method: `session.agent.getCurrent`.
    ///
    /// # Returns
    ///
    /// The currently selected custom agent, or null when using the default agent.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_current(&self) -> Result<AgentGetCurrentResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_AGENT_GETCURRENT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Selects a custom agent for subsequent turns in the session.
    ///
    /// Wire method: `session.agent.select`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name of the custom agent to select for subsequent turns.
    ///
    /// # Returns
    ///
    /// The newly selected custom agent.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn select(&self, params: AgentSelectRequest) -> Result<AgentSelectResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_AGENT_SELECT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Clears the selected custom agent and returns the session to the default agent.
    ///
    /// Wire method: `session.agent.deselect`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn deselect(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_AGENT_DESELECT, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Reloads custom agent definitions and returns the refreshed list.
    ///
    /// Wire method: `session.agent.reload`.
    ///
    /// # Returns
    ///
    /// Custom agents available to the session after reloading definitions from disk.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload(&self) -> Result<AgentReloadResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_AGENT_RELOAD, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.canvas.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcCanvas<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcCanvas<'a> {
    /// `session.canvas.action.*` sub-namespace.
    pub fn action(&self) -> SessionRpcCanvasAction<'a> {
        SessionRpcCanvasAction {
            session: self.session,
        }
    }

    /// `session.canvas.provider.*` sub-namespace.
    pub fn provider(&self) -> SessionRpcCanvasProvider<'a> {
        SessionRpcCanvasProvider {
            session: self.session,
        }
    }

    /// Lists canvases declared for the session.
    ///
    /// Wire method: `session.canvas.list`.
    ///
    /// # Returns
    ///
    /// Declared canvases available in this session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<CanvasList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_CANVAS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists currently open canvas instances for the live session.
    ///
    /// Wire method: `session.canvas.listOpen`.
    ///
    /// # Returns
    ///
    /// Live open-canvas snapshot.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_open(&self) -> Result<CanvasListOpenResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_CANVAS_LISTOPEN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Opens or focuses a canvas instance.
    ///
    /// Wire method: `session.canvas.open`.
    ///
    /// # Parameters
    ///
    /// * `params` - Canvas open parameters.
    ///
    /// # Returns
    ///
    /// Open canvas instance snapshot.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn open(&self, params: CanvasOpenRequest) -> Result<OpenCanvasInstance, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_CANVAS_OPEN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Closes an open canvas instance.
    ///
    /// Wire method: `session.canvas.close`.
    ///
    /// # Parameters
    ///
    /// * `params` - Canvas close parameters.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn close(&self, params: CanvasCloseRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_CANVAS_CLOSE, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `session.canvas.action.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcCanvasAction<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcCanvasAction<'a> {
    /// Invokes an action on an open canvas instance.
    ///
    /// Wire method: `session.canvas.action.invoke`.
    ///
    /// # Parameters
    ///
    /// * `params` - Canvas action invocation parameters.
    ///
    /// # Returns
    ///
    /// Canvas action invocation result.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn invoke(
        &self,
        params: CanvasActionInvokeRequest,
    ) -> Result<CanvasActionInvokeResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_CANVAS_ACTION_INVOKE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.canvas.provider.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcCanvasProvider<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcCanvasProvider<'a> {
    /// Registers an internal canvas provider connection and its contributions.
    ///
    /// Wire method: `session.canvas.provider.register`.
    ///
    /// # Parameters
    ///
    /// * `params` - Internal canvas provider registration parameters.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn register(
        &self,
        params: CanvasProviderRegisterRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_CANVAS_PROVIDER_REGISTER,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Unregisters an internal canvas provider connection.
    ///
    /// Wire method: `session.canvas.provider.unregister`.
    ///
    /// # Parameters
    ///
    /// * `params` - Internal canvas provider unregistration parameters.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn unregister(
        &self,
        params: CanvasProviderUnregisterRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_CANVAS_PROVIDER_UNREGISTER,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }
}

/// `session.commands.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcCommands<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcCommands<'a> {
    /// Lists slash commands available in the session.
    ///
    /// Wire method: `session.commands.list`.
    ///
    /// # Returns
    ///
    /// Slash commands available in the session, after applying any include/exclude filters.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<CommandList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_COMMANDS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists slash commands available in the session.
    ///
    /// Wire method: `session.commands.list`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional filters controlling which command sources to include in the listing.
    ///
    /// # Returns
    ///
    /// Slash commands available in the session, after applying any include/exclude filters.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_with_params(
        &self,
        params: CommandsListRequest,
    ) -> Result<CommandList, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_COMMANDS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Invokes a slash command in the session.
    ///
    /// Wire method: `session.commands.invoke`.
    ///
    /// # Parameters
    ///
    /// * `params` - Slash command name and optional raw input string to invoke.
    ///
    /// # Returns
    ///
    /// Result of invoking the slash command (text output, prompt to send to the agent, completion, or subcommand selection).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn invoke(
        &self,
        params: CommandsInvokeRequest,
    ) -> Result<SlashCommandInvocationResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_COMMANDS_INVOKE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Finalizes persistence associated with a client-applied slash-command effect.
    ///
    /// Wire method: `session.commands.finalizeInvocationEffect`.
    ///
    /// # Parameters
    ///
    /// * `params` - The pending slash-command invocation effect to finalize, plus whether the host applied or cancelled it.
    ///
    /// # Returns
    ///
    /// Whether finalizing the invocation effect succeeded, and the failure reason when it did not.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn finalize_invocation_effect(
        &self,
        params: CommandsFinalizeInvocationEffectRequest,
    ) -> Result<CommandsFinalizeInvocationEffectResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_COMMANDS_FINALIZEINVOCATIONEFFECT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reports completion of a pending client-handled slash command.
    ///
    /// Wire method: `session.commands.handlePendingCommand`.
    ///
    /// # Parameters
    ///
    /// * `params` - Pending command request ID and an optional error if the client handler failed.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending client-handled command was completed successfully.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_command(
        &self,
        params: CommandsHandlePendingCommandRequest,
    ) -> Result<CommandsHandlePendingCommandResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_COMMANDS_HANDLEPENDINGCOMMAND,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Executes a slash command synchronously and returns any error.
    ///
    /// Wire method: `session.commands.execute`.
    ///
    /// # Parameters
    ///
    /// * `params` - Slash command name and argument string to execute synchronously.
    ///
    /// # Returns
    ///
    /// Error message produced while executing the command, if any.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn execute(
        &self,
        params: ExecuteCommandParams,
    ) -> Result<ExecuteCommandResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_COMMANDS_EXECUTE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enqueues a slash command for FIFO processing on the local session.
    ///
    /// Wire method: `session.commands.enqueue`.
    ///
    /// # Parameters
    ///
    /// * `params` - Slash-prefixed command string to enqueue for FIFO processing.
    ///
    /// # Returns
    ///
    /// Indicates whether the command was accepted into the local execution queue.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enqueue(
        &self,
        params: EnqueueCommandParams,
    ) -> Result<EnqueueCommandResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_COMMANDS_ENQUEUE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reports whether the host actually executed a queued command and whether to continue processing.
    ///
    /// Wire method: `session.commands.respondToQueuedCommand`.
    ///
    /// # Parameters
    ///
    /// * `params` - Queued-command request ID and the result indicating whether the host executed it (and whether to stop processing further queued commands).
    ///
    /// # Returns
    ///
    /// Indicates whether the queued-command response was matched to a pending request.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn respond_to_queued_command(
        &self,
        params: CommandsRespondToQueuedCommandRequest,
    ) -> Result<CommandsRespondToQueuedCommandResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_COMMANDS_RESPONDTOQUEUEDCOMMAND,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.completions.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcCompletions<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcCompletions<'a> {
    /// 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).
    ///
    /// Wire method: `session.completions.getTriggerCharacters`.
    ///
    /// # 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`).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_trigger_characters(
        &self,
    ) -> Result<CompletionsGetTriggerCharactersResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_COMPLETIONS_GETTRIGGERCHARACTERS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.completions.request`.
    ///
    /// # Parameters
    ///
    /// * `params` - Request host-driven completions for the current composer input.
    ///
    /// # Returns
    ///
    /// Host-driven completion items for the current composer input. Empty when the host returns no items or does not support completions.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn request(
        &self,
        params: CompletionsRequestRequest,
    ) -> Result<CompletionsRequestResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_COMPLETIONS_REQUEST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.contentExclusion.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcContentExclusion<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcContentExclusion<'a> {
    /// 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.
    ///
    /// Wire method: `session.contentExclusion.checkPaths`.
    ///
    /// # Parameters
    ///
    /// * `params` - Local file system absolute paths within the session working directory to check against its content-exclusion policy.
    ///
    /// # Returns
    ///
    /// Batch content-exclusion result. Callers must fail closed when policy evaluation is unavailable.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn check_paths(
        &self,
        params: ContentExclusionCheckPathsRequest,
    ) -> Result<ContentExclusionCheckPathsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_CONTENTEXCLUSION_CHECKPATHS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.debug.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcDebug<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcDebug<'a> {
    /// 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.
    ///
    /// Wire method: `session.debug.collectLogs`.
    ///
    /// # Parameters
    ///
    /// * `params` - Options for collecting a redacted session debug bundle.
    ///
    /// # Returns
    ///
    /// Result of collecting a redacted debug bundle.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn collect_logs(
        &self,
        params: DebugCollectLogsRequest,
    ) -> Result<DebugCollectLogsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_DEBUG_COLLECTLOGS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.eventLog.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcEventLog<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcEventLog<'a> {
    /// Reads a batch of session events from a cursor, optionally waiting for new events. Supports tail-first reads via `direction: backward`.
    ///
    /// Wire method: `session.eventLog.read`.
    ///
    /// # Parameters
    ///
    /// * `params` - Cursor, batch size, and optional long-poll/filter parameters for reading session events.
    ///
    /// # Returns
    ///
    /// Batch of session events returned by a read, with cursor and continuation metadata.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read(&self, params: EventLogReadRequest) -> Result<EventsReadResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_EVENTLOG_READ, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns a snapshot of the current tail cursor without consuming events.
    ///
    /// Wire method: `session.eventLog.tail`.
    ///
    /// # 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).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn tail(&self) -> Result<EventLogTailResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_EVENTLOG_TAIL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers consumer interest in an event type for runtime gating purposes.
    ///
    /// Wire method: `session.eventLog.registerInterest`.
    ///
    /// # Parameters
    ///
    /// * `params` - Event type to register consumer interest for, used by runtime gating logic.
    ///
    /// # Returns
    ///
    /// Opaque handle representing an event-type interest registration.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn register_interest(
        &self,
        params: RegisterEventInterestParams,
    ) -> Result<RegisterEventInterestResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_EVENTLOG_REGISTERINTEREST,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Releases a consumer's previously-registered interest in an event type.
    ///
    /// Wire method: `session.eventLog.releaseInterest`.
    ///
    /// # Parameters
    ///
    /// * `params` - Opaque handle previously returned by `registerInterest` to release.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn release_interest(
        &self,
        params: ReleaseEventInterestParams,
    ) -> Result<EventLogReleaseInterestResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_EVENTLOG_RELEASEINTEREST,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.extensions.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcExtensions<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcExtensions<'a> {
    /// Lists extensions discovered for the session and their current status.
    ///
    /// Wire method: `session.extensions.list`.
    ///
    /// # Returns
    ///
    /// Extensions discovered for the session, with their current status.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<ExtensionList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_EXTENSIONS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enables an extension for the session.
    ///
    /// Wire method: `session.extensions.enable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Source-qualified extension identifier to enable for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enable(&self, params: ExtensionsEnableRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_EXTENSIONS_ENABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Disables an extension for the session.
    ///
    /// Wire method: `session.extensions.disable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Source-qualified extension identifier to disable for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn disable(&self, params: ExtensionsDisableRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_EXTENSIONS_DISABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Reloads extension definitions and processes for the session.
    ///
    /// Wire method: `session.extensions.reload`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_EXTENSIONS_RELOAD, Some(wire_params))
            .await?;
        Ok(())
    }

    /// 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.
    ///
    /// Wire method: `session.extensions.sendAttachmentsToMessage`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for session.extensions.sendAttachmentsToMessage.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn send_attachments_to_message(
        &self,
        params: SendAttachmentsToMessageParams,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_EXTENSIONS_SENDATTACHMENTSTOMESSAGE,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }
}

/// `session.factory.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcFactory<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcFactory<'a> {
    /// `session.factory.journal.*` sub-namespace.
    pub fn journal(&self) -> SessionRpcFactoryJournal<'a> {
        SessionRpcFactoryJournal {
            session: self.session,
        }
    }

    /// Runs a registered factory by name at the top level.
    ///
    /// Wire method: `session.factory.run`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for invoking a registered factory.
    ///
    /// # Returns
    ///
    /// Complete current or terminal factory run envelope.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn run(&self, params: FactoryRunRequest) -> Result<FactoryRunResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_RUN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resumes a factory run using its persisted name, arguments, journal, and accounting.
    ///
    /// Wire method: `session.factory.resume`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for resuming a factory run from its persisted identity.
    ///
    /// # Returns
    ///
    /// Resolved persisted factory identity and resumed run envelope.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn resume(&self, params: FactoryResumeRequest) -> Result<FactoryResumeResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_RESUME, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets the current or settled envelope for a factory run.
    ///
    /// Wire method: `session.factory.getRun`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for retrieving a factory run.
    ///
    /// # Returns
    ///
    /// Complete current or terminal factory run envelope.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_run(&self, params: FactoryGetRunRequest) -> Result<FactoryRunResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_GETRUN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists durable factory runs for this session in creation order.
    ///
    /// Wire method: `session.factory.listRuns`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for paging factory runs.
    ///
    /// # Returns
    ///
    /// A page of factory runs in durable creation order.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_runs(
        &self,
        params: FactoryListRunsRequest,
    ) -> Result<FactoryListRunsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_LISTRUNS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets durable and live observability detail for one factory run.
    ///
    /// Wire method: `session.factory.getRunDetail`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for retrieving a factory run.
    ///
    /// # Returns
    ///
    /// Full factory run observability detail.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_run_detail(
        &self,
        params: FactoryGetRunRequest,
    ) -> Result<FactoryRunDetail, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_GETRUNDETAIL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Pages durable progress for one factory run.
    ///
    /// Wire method: `session.factory.getRunProgress`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for paging factory progress.
    ///
    /// # Returns
    ///
    /// A bidirectional page of factory progress.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_run_progress(
        &self,
        params: FactoryGetRunProgressRequest,
    ) -> Result<FactoryProgressPage, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_FACTORY_GETRUNPROGRESS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Requests cancellation of a factory run and returns its run envelope.
    ///
    /// Wire method: `session.factory.cancel`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for cancelling a factory run.
    ///
    /// # Returns
    ///
    /// Complete current or terminal factory run envelope.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn cancel(&self, params: FactoryCancelRequest) -> Result<FactoryRunResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_CANCEL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Records a batch of ordered factory progress lines.
    ///
    /// Wire method: `session.factory.log`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for recording factory progress.
    ///
    /// # Returns
    ///
    /// Acknowledgement that a factory request was accepted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn log(&self, params: FactoryLogRequest) -> Result<FactoryAckResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_LOG, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Runs one factory-scoped subagent and returns its result.
    ///
    /// Wire method: `session.factory.agent`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for one factory-scoped subagent call.
    ///
    /// # Returns
    ///
    /// Result of one factory-scoped subagent call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn agent(&self, params: FactoryAgentRequest) -> Result<FactoryAgentResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_AGENT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.factory.journal.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcFactoryJournal<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcFactoryJournal<'a> {
    /// Reads a memoized factory journal entry.
    ///
    /// Wire method: `session.factory.journal.get`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for reading a factory journal entry.
    ///
    /// # Returns
    ///
    /// Result of reading a factory journal entry.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get(
        &self,
        params: FactoryJournalGetRequest,
    ) -> Result<FactoryJournalGetResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_JOURNAL_GET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Stores a memoized factory journal entry.
    ///
    /// Wire method: `session.factory.journal.put`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for storing a factory journal entry.
    ///
    /// # Returns
    ///
    /// Acknowledgement that a factory request was accepted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn put(&self, params: FactoryJournalPutRequest) -> Result<FactoryAckResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FACTORY_JOURNAL_PUT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.fleet.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcFleet<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcFleet<'a> {
    /// Starts fleet mode by submitting the fleet orchestration prompt to the session.
    ///
    /// Wire method: `session.fleet.start`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional user prompt to combine with the fleet orchestration instructions.
    ///
    /// # Returns
    ///
    /// Indicates whether fleet mode was successfully activated.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn start(&self, params: FleetStartRequest) -> Result<FleetStartResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_FLEET_START, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.gitHubAuth.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcGitHubAuth<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcGitHubAuth<'a> {
    /// Gets authentication status and account metadata for the session.
    ///
    /// Wire method: `session.gitHubAuth.getStatus`.
    ///
    /// # Returns
    ///
    /// Authentication status and account metadata for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_status(&self) -> Result<SessionAuthStatus, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_GITHUBAUTH_GETSTATUS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Updates the session's auth credentials used for outbound model and API requests.
    ///
    /// Wire method: `session.gitHubAuth.setCredentials`.
    ///
    /// # Parameters
    ///
    /// * `params` - New auth credentials to install on the session. Omit to leave credentials unchanged.
    ///
    /// # Returns
    ///
    /// Indicates whether the credential update succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_credentials(
        &self,
        params: SessionSetCredentialsParams,
    ) -> Result<SessionSetCredentialsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_GITHUBAUTH_SETCREDENTIALS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets the current authentication information for internal session hosts.
    ///
    /// Wire method: `session.gitHubAuth.getCurrentAuthInfo`.
    ///
    /// # Returns
    ///
    /// Current authentication information, or null when no authentication is active.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn get_current_auth_info(&self) -> Result<SessionAuthInfoResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_GITHUBAUTH_GETCURRENTAUTHINFO,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets all authentication accounts available to the internal session host.
    ///
    /// Wire method: `session.gitHubAuth.getAllAuthAvailable`.
    ///
    /// # Returns
    ///
    /// Authentication accounts available to the internal session host.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn get_all_auth_available(
        &self,
    ) -> Result<SessionGitHubAuthGetAllAuthAvailableResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_GITHUBAUTH_GETALLAUTHAVAILABLE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Refreshes Copilot account metadata for the current authentication.
    ///
    /// Wire method: `session.gitHubAuth.refreshCopilotUser`.
    ///
    /// # Returns
    ///
    /// Current authentication information, or null when no authentication is active.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn refresh_copilot_user(&self) -> Result<SessionAuthInfoResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_GITHUBAUTH_REFRESHCOPILOTUSER,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Logs in a GitHub user through the internal session host.
    ///
    /// Wire method: `session.gitHubAuth.login`.
    ///
    /// # Parameters
    ///
    /// * `params` - Internal GitHub login parameters.
    ///
    /// # Returns
    ///
    /// Authentication credentials accepted only at native protocol ingress. Runtime outputs use credential-free `AuthIdentity` metadata.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn login(&self, params: SessionAuthLoginRequest) -> Result<AuthInfo, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_GITHUBAUTH_LOGIN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Switches the session to another available authentication.
    ///
    /// Wire method: `session.gitHubAuth.switchToAuth`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for switching the session's active authentication.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn switch_to_auth(
        &self,
        params: SessionAuthSwitchRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_GITHUBAUTH_SWITCHTOAUTH,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Logs out the session's current GitHub authentication.
    ///
    /// Wire method: `session.gitHubAuth.logout`.
    ///
    /// # Returns
    ///
    /// Whether the current authentication was logged out.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn logout(&self) -> Result<SessionGitHubAuthLogoutResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_GITHUBAUTH_LOGOUT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Logs out a specific GitHub authentication.
    ///
    /// Wire method: `session.gitHubAuth.logoutUser`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters identifying a GitHub authentication to log out.
    ///
    /// # Returns
    ///
    /// Whether the requested authentication was logged out.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn logout_user(
        &self,
        params: SessionAuthLogoutUserRequest,
    ) -> Result<SessionGitHubAuthLogoutUserResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_GITHUBAUTH_LOGOUTUSER,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Gets validation errors from the most recent authentication attempt.
    ///
    /// Wire method: `session.gitHubAuth.lastAuthErrors`.
    ///
    /// # Returns
    ///
    /// Validation errors from the most recent authentication attempt.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn last_auth_errors(&self) -> Result<AuthValidationErrors, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_GITHUBAUTH_LASTAUTHERRORS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.history.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcHistory<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcHistory<'a> {
    /// Compacts the session history to reduce context usage.
    ///
    /// Wire method: `session.history.compact`.
    ///
    /// # Returns
    ///
    /// Compaction outcome with the number of tokens and messages removed, summary text, and the resulting context window breakdown.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn compact(&self) -> Result<HistoryCompactResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_HISTORY_COMPACT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Compacts the session history to reduce context usage.
    ///
    /// Wire method: `session.history.compact`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional compaction parameters.
    ///
    /// # Returns
    ///
    /// Compaction outcome with the number of tokens and messages removed, summary text, and the resulting context window breakdown.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn compact_with_params(
        &self,
        params: HistoryCompactRequest,
    ) -> Result<HistoryCompactResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_HISTORY_COMPACT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Truncates persisted session history to a specific event.
    ///
    /// Wire method: `session.history.truncate`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of the event to truncate to; this event and all later events are removed.
    ///
    /// # Returns
    ///
    /// Number of events that were removed by the truncation.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn truncate(
        &self,
        params: HistoryTruncateRequest,
    ) -> Result<HistoryTruncateResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_HISTORY_TRUNCATE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.history.listRewindPoints`.
    ///
    /// # Returns
    ///
    /// Rewind points and file-change-tracking availability for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_rewind_points(&self) -> Result<HistoryListRewindPointsResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_HISTORY_LISTREWINDPOINTS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Previews the files that a conversation-and-files rewind would restore.
    ///
    /// Wire method: `session.history.previewRewind`.
    ///
    /// # Parameters
    ///
    /// * `params` - Event boundary to preview for conversation-and-files rewind.
    ///
    /// # Returns
    ///
    /// Files and aggregate changes for a prospective rewind.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn preview_rewind(
        &self,
        params: HistoryPreviewRewindRequest,
    ) -> Result<HistoryPreviewRewindResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_HISTORY_PREVIEWREWIND,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.history.rewind`.
    ///
    /// # Parameters
    ///
    /// * `params` - Boundary and mode for rewinding session history.
    ///
    /// # Returns
    ///
    /// Structured outcome of a rewind request.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn rewind(&self, params: HistoryRewindRequest) -> Result<HistoryRewindResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_HISTORY_REWIND, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Cancels any in-progress background compaction on a local session.
    ///
    /// Wire method: `session.history.cancelBackgroundCompaction`.
    ///
    /// # Returns
    ///
    /// Indicates whether an in-progress background compaction was cancelled.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn cancel_background_compaction(
        &self,
    ) -> Result<HistoryCancelBackgroundCompactionResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_HISTORY_CANCELBACKGROUNDCOMPACTION,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Aborts any in-progress manual compaction on a local session.
    ///
    /// Wire method: `session.history.abortManualCompaction`.
    ///
    /// # Returns
    ///
    /// Indicates whether an in-progress manual compaction was aborted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn abort_manual_compaction(
        &self,
    ) -> Result<HistoryAbortManualCompactionResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_HISTORY_ABORTMANUALCOMPACTION,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Produces a markdown summary of the session's conversation context for hand-off scenarios.
    ///
    /// Wire method: `session.history.summarizeForHandoff`.
    ///
    /// # Returns
    ///
    /// Markdown summary of the conversation context (empty when not available).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn summarize_for_handoff(&self) -> Result<HistorySummarizeForHandoffResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_HISTORY_SUMMARIZEFORHANDOFF,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.history.clearContext`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for clearing the conversation and seeding the window that replaces it.
    ///
    /// # Returns
    ///
    /// What a successful clear removed. A clear that could not be applied rejects instead of reporting a count.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn clear_context(
        &self,
        params: HistoryClearContextRequest,
    ) -> Result<HistoryClearContextResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_HISTORY_CLEARCONTEXT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.instructions.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcInstructions<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcInstructions<'a> {
    /// Gets instruction sources loaded for the session.
    ///
    /// Wire method: `session.instructions.getSources`.
    ///
    /// # Returns
    ///
    /// Instruction sources loaded for the session, in merge order.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_sources(&self) -> Result<InstructionsGetSourcesResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_INSTRUCTIONS_GETSOURCES,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.limitPrediction.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcLimitPrediction<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcLimitPrediction<'a> {
    /// 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.
    ///
    /// Wire method: `session.limitPrediction.predict`.
    ///
    /// # Returns
    ///
    /// Prediction result. Available results include prediction details; unavailable results include an explicit reason.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn predict(&self) -> Result<SessionLimitPredictionResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_LIMITPREDICTION_PREDICT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.limitPrediction.predict`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for predicting an AI-credit session limit. Omitting `modelId` uses the session's currently selected model.
    ///
    /// # Returns
    ///
    /// Prediction result. Available results include prediction details; unavailable results include an explicit reason.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn predict_with_params(
        &self,
        params: SessionLimitPredictionRequest,
    ) -> Result<SessionLimitPredictionResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_LIMITPREDICTION_PREDICT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.lsp.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcLsp<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcLsp<'a> {
    /// Loads the merged LSP configuration set for the session's working directory.
    ///
    /// Wire method: `session.lsp.initialize`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for (re)loading the merged LSP configuration set.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn initialize(&self, params: LspInitializeRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_LSP_INITIALIZE, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `session.mcp.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcMcp<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcMcp<'a> {
    /// `session.mcp.apps.*` sub-namespace.
    pub fn apps(&self) -> SessionRpcMcpApps<'a> {
        SessionRpcMcpApps {
            session: self.session,
        }
    }

    /// `session.mcp.headers.*` sub-namespace.
    pub fn headers(&self) -> SessionRpcMcpHeaders<'a> {
        SessionRpcMcpHeaders {
            session: self.session,
        }
    }

    /// `session.mcp.oauth.*` sub-namespace.
    pub fn oauth(&self) -> SessionRpcMcpOauth<'a> {
        SessionRpcMcpOauth {
            session: self.session,
        }
    }

    /// `session.mcp.resources.*` sub-namespace.
    pub fn resources(&self) -> SessionRpcMcpResources<'a> {
        SessionRpcMcpResources {
            session: self.session,
        }
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.list`.
    ///
    /// # Returns
    ///
    /// MCP servers configured for the session, with their connection status and host-level state.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<McpServerList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.listTools`.
    ///
    /// # Parameters
    ///
    /// * `params` - Server name whose tool list should be returned.
    ///
    /// # Returns
    ///
    /// Tools exposed by the connected MCP server. Throws when the server is not connected.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_tools(
        &self,
        params: McpListToolsRequest,
    ) -> Result<McpListToolsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_LISTTOOLS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enables an MCP server for the session.
    ///
    /// Wire method: `session.mcp.enable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name of the MCP server to enable for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enable(&self, params: McpEnableRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_ENABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Disables an MCP server for the session.
    ///
    /// Wire method: `session.mcp.disable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name of the MCP server to disable for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn disable(&self, params: McpDisableRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_DISABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Reloads MCP server connections for the session.
    ///
    /// Wire method: `session.mcp.reload`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_RELOAD, Some(wire_params))
            .await?;
        Ok(())
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.moveLoadingToBackground`.
    ///
    /// # Returns
    ///
    /// Result of moving in-flight MCP loading to the background.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn move_loading_to_background(
        &self,
    ) -> Result<MoveMcpLoadingToBackgroundResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_MOVELOADINGTOBACKGROUND,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reloads MCP server connections for the session with an explicit host-provided configuration.
    ///
    /// Wire method: `session.mcp.reloadWithConfig`.
    ///
    /// # Parameters
    ///
    /// * `params` - Opaque MCP reload configuration.
    ///
    /// # Returns
    ///
    /// MCP server startup filtering result.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn reload_with_config(
        &self,
        params: McpReloadWithConfigRequest,
    ) -> Result<McpStartServersResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_RELOADWITHCONFIG, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Runs an MCP sampling inference on behalf of an MCP server.
    ///
    /// Wire method: `session.mcp.executeSampling`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifiers and raw MCP CreateMessageRequest params used to run a sampling inference.
    ///
    /// # Returns
    ///
    /// Outcome of an MCP sampling execution: success result, failure error, or cancellation.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn execute_sampling(
        &self,
        params: McpExecuteSamplingParams,
    ) -> Result<McpSamplingExecutionResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_EXECUTESAMPLING, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Cancels an in-flight MCP sampling execution by request ID.
    ///
    /// Wire method: `session.mcp.cancelSamplingExecution`.
    ///
    /// # Parameters
    ///
    /// * `params` - The requestId previously passed to executeSampling that should be cancelled.
    ///
    /// # Returns
    ///
    /// Indicates whether an in-flight sampling execution with the given requestId was found and cancelled.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn cancel_sampling_execution(
        &self,
        params: McpCancelSamplingExecutionParams,
    ) -> Result<McpCancelSamplingExecutionResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_CANCELSAMPLINGEXECUTION,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Sets how environment-variable values supplied to MCP servers are resolved (direct or indirect).
    ///
    /// Wire method: `session.mcp.setEnvValueMode`.
    ///
    /// # Parameters
    ///
    /// * `params` - Mode controlling how MCP server env values are resolved (`direct` or `indirect`).
    ///
    /// # Returns
    ///
    /// Env-value mode recorded on the session after the update.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_env_value_mode(
        &self,
        params: McpSetEnvValueModeParams,
    ) -> Result<McpSetEnvValueModeResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_SETENVVALUEMODE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Removes the auto-managed `github` MCP server when present.
    ///
    /// Wire method: `session.mcp.removeGitHub`.
    ///
    /// # Returns
    ///
    /// Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn remove_git_hub(&self) -> Result<McpRemoveGitHubResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_REMOVEGITHUB, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Configures the built-in GitHub MCP server for the session's current auth context.
    ///
    /// Wire method: `session.mcp.configureGitHub`.
    ///
    /// # Parameters
    ///
    /// * `params` - Credential-free authentication identity used to configure GitHub MCP.
    ///
    /// # Returns
    ///
    /// Result of configuring GitHub MCP.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn configure_git_hub(
        &self,
        params: McpConfigureGitHubRequest,
    ) -> Result<McpConfigureGitHubResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_CONFIGUREGITHUB, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.startServer`.
    ///
    /// # Parameters
    ///
    /// * `params` - 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn start_server(&self, params: McpStartServerRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_STARTSERVER, Some(wire_params))
            .await?;
        Ok(())
    }

    /// 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.*`).
    ///
    /// Wire method: `session.mcp.restartServer`.
    ///
    /// # Parameters
    ///
    /// * `params` - 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn restart_server(&self, params: McpRestartServerRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_RESTARTSERVER, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Stops an individual MCP server on the session's host.
    ///
    /// Wire method: `session.mcp.stopServer`.
    ///
    /// # Parameters
    ///
    /// * `params` - Server name for an individual MCP server stop.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn stop_server(&self, params: McpStopServerRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_STOPSERVER, Some(wire_params))
            .await?;
        Ok(())
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.registerExternalClient`.
    ///
    /// # Parameters
    ///
    /// * `params` - Registration parameters for an external MCP client.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn register_external_client(
        &self,
        params: McpRegisterExternalClientRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_REGISTEREXTERNALCLIENT,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.unregisterExternalClient`.
    ///
    /// # Parameters
    ///
    /// * `params` - Server name identifying the external client to remove.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn unregister_external_client(
        &self,
        params: McpUnregisterExternalClientRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_UNREGISTEREXTERNALCLIENT,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Checks whether a named MCP server is currently running on the session's host.
    ///
    /// Wire method: `session.mcp.isServerRunning`.
    ///
    /// # Parameters
    ///
    /// * `params` - Server name to check running status for.
    ///
    /// # Returns
    ///
    /// Whether the named MCP server is running.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn is_server_running(
        &self,
        params: McpIsServerRunningRequest,
    ) -> Result<McpIsServerRunningResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_ISSERVERRUNNING, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.mcp.apps.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcMcpApps<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcMcpApps<'a> {
    /// Fetch an MCP resource (typically a `ui://` MCP App bundle, per SEP-1865) from a connected server. Requires the `mcp-apps` session capability.
    ///
    /// Wire method: `session.mcp.apps.readResource`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server and resource URI to fetch.
    ///
    /// # Returns
    ///
    /// Resource contents returned by the MCP server.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read_resource(
        &self,
        params: McpAppsReadResourceRequest,
    ) -> Result<McpAppsReadResourceResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_APPS_READRESOURCE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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"`.
    ///
    /// Wire method: `session.mcp.apps.listTools`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server to list app-callable tools for.
    ///
    /// # Returns
    ///
    /// App-callable tools from the named MCP server.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_tools(
        &self,
        params: McpAppsListToolsRequest,
    ) -> Result<McpAppsListToolsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_APPS_LISTTOOLS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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`.
    ///
    /// Wire method: `session.mcp.apps.callTool`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server, tool name, and arguments to invoke from an MCP App view.
    ///
    /// # Returns
    ///
    /// Standard MCP CallToolResult
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn call_tool(
        &self,
        params: McpAppsCallToolRequest,
    ) -> Result<SessionMcpAppsCallToolResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_APPS_CALLTOOL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.apps.setHostContext`.
    ///
    /// # Parameters
    ///
    /// * `params` - Host context to advertise to MCP App guests.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_host_context(
        &self,
        params: McpAppsSetHostContextRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_APPS_SETHOSTCONTEXT,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Read the current host context advertised to MCP App guests.
    ///
    /// Wire method: `session.mcp.apps.getHostContext`.
    ///
    /// # Returns
    ///
    /// Current host context advertised to MCP App guests.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_host_context(&self) -> Result<McpAppsHostContext, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_APPS_GETHOSTCONTEXT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.apps.diagnose`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server to diagnose MCP Apps wiring for.
    ///
    /// # Returns
    ///
    /// Diagnostic snapshot of MCP Apps wiring for the named server.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn diagnose(
        &self,
        params: McpAppsDiagnoseRequest,
    ) -> Result<McpAppsDiagnoseResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_APPS_DIAGNOSE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.mcp.headers.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcMcpHeaders<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcMcpHeaders<'a> {
    /// 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.
    ///
    /// Wire method: `session.mcp.headers.handlePendingHeadersRefreshRequest`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP headers refresh request id and the host response.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending MCP headers refresh response was accepted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_headers_refresh_request(
        &self,
        params: McpHeadersHandlePendingHeadersRefreshRequestRequest,
    ) -> Result<McpHeadersHandlePendingHeadersRefreshRequestResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_HEADERS_HANDLEPENDINGHEADERSREFRESHREQUEST,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.mcp.oauth.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcMcpOauth<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcMcpOauth<'a> {
    /// 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.
    ///
    /// Wire method: `session.mcp.oauth.handlePendingRequest`.
    ///
    /// # Parameters
    ///
    /// * `params` - Pending MCP OAuth request ID and host-provided token or cancellation response.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending MCP OAuth response was accepted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_request(
        &self,
        params: McpOauthHandlePendingRequest,
    ) -> Result<McpOauthHandlePendingResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_OAUTH_HANDLEPENDINGREQUEST,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Notifies the session that MCP OAuth authentication succeeded and updated credentials were persisted, so cached tool definitions can be refreshed.
    ///
    /// Wire method: `session.mcp.oauth.authenticationStateChanged`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifies the MCP server whose persisted OAuth credentials were updated.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn authentication_state_changed(
        &self,
        params: McpOauthAuthenticationStateChangedRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_OAUTH_AUTHENTICATIONSTATECHANGED,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Starts OAuth authentication for a remote MCP server.
    ///
    /// Wire method: `session.mcp.oauth.login`.
    ///
    /// # Parameters
    ///
    /// * `params` - Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.
    ///
    /// # Returns
    ///
    /// OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn login(&self, params: McpOauthLoginRequest) -> Result<McpOauthLoginResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_OAUTH_LOGIN, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.mcp.oauth.probe`.
    ///
    /// # Parameters
    ///
    /// * `params` - Remote MCP server name for a passive OAuth status probe.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn probe(&self, params: McpOauthProbeRequest) -> Result<McpOauthProbeResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_OAUTH_PROBE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Responds to a pending MCP OAuth authorization request by its request id.
    ///
    /// Wire method: `session.mcp.oauth.respond`.
    ///
    /// # Parameters
    ///
    /// * `params` - Pending MCP OAuth request id to respond to.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending MCP OAuth response was accepted.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn respond(
        &self,
        params: McpOauthRespondRequest,
    ) -> Result<McpOauthRespondResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_OAUTH_RESPOND, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.mcp.resources.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcMcpResources<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcMcpResources<'a> {
    /// Fetch an MCP resource from a connected server by URI (proxies MCP `resources/read`).
    ///
    /// Wire method: `session.mcp.resources.read`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server and resource URI to fetch.
    ///
    /// # Returns
    ///
    /// Resource contents returned by the MCP server.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read(
        &self,
        params: McpResourcesReadRequest,
    ) -> Result<McpResourcesReadResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_RESOURCES_READ, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enumerate one page of resources a connected MCP server exposes (proxies MCP `resources/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
    ///
    /// Wire method: `session.mcp.resources.list`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server whose resources to enumerate.
    ///
    /// # Returns
    ///
    /// One page of resources advertised by the named MCP server.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(
        &self,
        params: McpResourcesListRequest,
    ) -> Result<McpResourcesListResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MCP_RESOURCES_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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`.
    ///
    /// Wire method: `session.mcp.resources.listTemplates`.
    ///
    /// # Parameters
    ///
    /// * `params` - MCP server whose resource templates to enumerate.
    ///
    /// # Returns
    ///
    /// One page of resource templates advertised by the named MCP server.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_templates(
        &self,
        params: McpResourcesListTemplatesRequest,
    ) -> Result<McpResourcesListTemplatesResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MCP_RESOURCES_LISTTEMPLATES,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.metadata.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcMetadata<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcMetadata<'a> {
    /// Returns a snapshot of the session's identifying metadata, mode, agent, and remote info.
    ///
    /// Wire method: `session.metadata.snapshot`.
    ///
    /// # Returns
    ///
    /// Point-in-time snapshot of slow-changing session identifier and state fields
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn snapshot(&self) -> Result<SessionMetadataSnapshot, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_METADATA_SNAPSHOT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reports whether the local session is currently processing user/agent messages.
    ///
    /// Wire method: `session.metadata.isProcessing`.
    ///
    /// # Returns
    ///
    /// Indicates whether the local session is currently processing a turn or background continuation.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn is_processing(&self) -> Result<MetadataIsProcessingResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_METADATA_ISPROCESSING,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns a snapshot of activity flags for the session.
    ///
    /// Wire method: `session.metadata.activity`.
    ///
    /// # Returns
    ///
    /// Current activity flags for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn activity(&self) -> Result<SessionActivity, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_METADATA_ACTIVITY, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the token breakdown for the session's current context window for a given model.
    ///
    /// Wire method: `session.metadata.contextInfo`.
    ///
    /// # Parameters
    ///
    /// * `params` - Model identifier and token limits used to compute the context-info breakdown.
    ///
    /// # Returns
    ///
    /// Token breakdown for the session's current context window, or null if uninitialized.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn context_info(
        &self,
        params: MetadataContextInfoRequest,
    ) -> Result<MetadataContextInfoResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_METADATA_CONTEXTINFO, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.metadata.getContextAttribution`.
    ///
    /// # Returns
    ///
    /// Per-source attribution breakdown for the session's current context window, or null if uninitialized.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_context_attribution(&self) -> Result<MetadataContextAttributionResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_METADATA_GETCONTEXTATTRIBUTION,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.metadata.getContextHeaviestMessages`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for the heaviest-messages query.
    ///
    /// # Returns
    ///
    /// The heaviest individual messages in the session's context window, most-expensive first.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_context_heaviest_messages(
        &self,
        params: MetadataContextHeaviestMessagesRequest,
    ) -> Result<MetadataContextHeaviestMessagesResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_METADATA_GETCONTEXTHEAVIESTMESSAGES,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.metadata.recordContextChange`.
    ///
    /// # Parameters
    ///
    /// * `params` - Updated working-directory/git context to record on the session.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn record_context_change(
        &self,
        params: MetadataRecordContextChangeRequest,
    ) -> Result<MetadataRecordContextChangeResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_METADATA_RECORDCONTEXTCHANGE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.metadata.setWorkingDirectory`.
    ///
    /// # Parameters
    ///
    /// * `params` - 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.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_working_directory(
        &self,
        params: MetadataSetWorkingDirectoryRequest,
    ) -> Result<MetadataSetWorkingDirectoryResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_METADATA_SETWORKINGDIRECTORY,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Re-tokenizes the session's existing messages against a model and returns aggregate token totals.
    ///
    /// Wire method: `session.metadata.recomputeContextTokens`.
    ///
    /// # Parameters
    ///
    /// * `params` - Model identifier to use when re-tokenizing the session's existing messages.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn recompute_context_tokens(
        &self,
        params: MetadataRecomputeContextTokensRequest,
    ) -> Result<MetadataRecomputeContextTokensResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_METADATA_RECOMPUTECONTEXTTOKENS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.mode.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcMode<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcMode<'a> {
    /// Gets the current agent interaction mode.
    ///
    /// Wire method: `session.mode.get`.
    ///
    /// # Returns
    ///
    /// The session mode the agent is operating in
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get(&self) -> Result<SessionMode, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MODE_GET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Sets the current agent interaction mode.
    ///
    /// Wire method: `session.mode.set`.
    ///
    /// # Parameters
    ///
    /// * `params` - Agent interaction mode to apply to the session.
    ///
    /// # Returns
    ///
    /// Outcome of a session mode change, including any model switch it triggered and follow-up the host must perform.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set(&self, params: ModeSetRequest) -> Result<ModeSetResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MODE_SET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.model.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcModel<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcModel<'a> {
    /// Gets the currently selected model for the session.
    ///
    /// Wire method: `session.model.getCurrent`.
    ///
    /// # Returns
    ///
    /// The currently selected model, reasoning effort, and context tier for the session. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_current(&self) -> Result<CurrentModel, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MODEL_GETCURRENT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Switches the session to a model and optional reasoning configuration.
    ///
    /// Wire method: `session.model.switchTo`.
    ///
    /// # Parameters
    ///
    /// * `params` - Target model identifier and optional reasoning effort, summary, capability overrides, and context tier.
    ///
    /// # Returns
    ///
    /// The model identifier active on the session after the switch.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn switch_to(
        &self,
        params: ModelSwitchToRequest,
    ) -> Result<ModelSwitchToResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MODEL_SWITCHTO, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves and applies organization-managed and repository model overlays.
    ///
    /// Wire method: `session.model.applyStartupOverlay`.
    ///
    /// # Parameters
    ///
    /// * `params` - Managed, repository, and CLI model overrides to overlay onto the session at startup.
    ///
    /// # Returns
    ///
    /// The model identifier active on the session after the switch.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn apply_startup_overlay(
        &self,
        params: ModelApplyStartupOverlayRequest,
    ) -> Result<ModelSwitchToResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MODEL_APPLYSTARTUPOVERLAY,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Updates the session's reasoning effort without changing the selected model.
    ///
    /// Wire method: `session.model.setReasoningEffort`.
    ///
    /// # Parameters
    ///
    /// * `params` - Reasoning effort level to apply to the currently selected model.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_reasoning_effort(
        &self,
        params: ModelSetReasoningEffortRequest,
    ) -> Result<ModelSetReasoningEffortResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_MODEL_SETREASONINGEFFORT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.model.list`.
    ///
    /// # Returns
    ///
    /// The list of models available to this session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<SessionModelList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MODEL_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.model.list`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional listing options.
    ///
    /// # Returns
    ///
    /// The list of models available to this session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_with_params(
        &self,
        params: ModelListRequest,
    ) -> Result<SessionModelList, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_MODEL_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.name.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcName<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcName<'a> {
    /// Gets the session's friendly name.
    ///
    /// Wire method: `session.name.get`.
    ///
    /// # Returns
    ///
    /// The session's friendly name, or null when not yet set.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get(&self) -> Result<NameGetResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_NAME_GET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Sets the session's friendly name.
    ///
    /// Wire method: `session.name.set`.
    ///
    /// # Parameters
    ///
    /// * `params` - New friendly name to apply to the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set(&self, params: NameSetRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_NAME_SET, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Persists an auto-generated session summary as the session's name when no user-set name exists.
    ///
    /// Wire method: `session.name.setAuto`.
    ///
    /// # Parameters
    ///
    /// * `params` - Auto-generated session summary to apply as the session's name when no user-set name exists.
    ///
    /// # Returns
    ///
    /// Indicates whether the auto-generated summary was applied as the session's name.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_auto(&self, params: NameSetAutoRequest) -> Result<NameSetAutoResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_NAME_SETAUTO, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.options.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcOptions<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcOptions<'a> {
    /// Patches the genuinely-mutable subset of session options.
    ///
    /// Wire method: `session.options.update`.
    ///
    /// # Parameters
    ///
    /// * `params` - Patch of mutable session options to apply to the running session.
    ///
    /// # Returns
    ///
    /// Indicates whether the session options patch was applied successfully.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update(
        &self,
        params: SessionUpdateOptionsParams,
    ) -> Result<SessionUpdateOptionsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_OPTIONS_UPDATE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.permissions.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcPermissions<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcPermissions<'a> {
    /// `session.permissions.folderTrust.*` sub-namespace.
    pub fn folder_trust(&self) -> SessionRpcPermissionsFolderTrust<'a> {
        SessionRpcPermissionsFolderTrust {
            session: self.session,
        }
    }

    /// `session.permissions.locations.*` sub-namespace.
    pub fn locations(&self) -> SessionRpcPermissionsLocations<'a> {
        SessionRpcPermissionsLocations {
            session: self.session,
        }
    }

    /// `session.permissions.paths.*` sub-namespace.
    pub fn paths(&self) -> SessionRpcPermissionsPaths<'a> {
        SessionRpcPermissionsPaths {
            session: self.session,
        }
    }

    /// `session.permissions.urls.*` sub-namespace.
    pub fn urls(&self) -> SessionRpcPermissionsUrls<'a> {
        SessionRpcPermissionsUrls {
            session: self.session,
        }
    }

    /// Replaces selected permission policy fields (rules, paths, URLs, exclusions, allow-all flags) on the session.
    ///
    /// Wire method: `session.permissions.configure`.
    ///
    /// # Parameters
    ///
    /// * `params` - Patch of permission policy fields to apply (omit a field to leave it unchanged).
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn configure(
        &self,
        params: PermissionsConfigureParams,
    ) -> Result<PermissionsConfigureResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_CONFIGURE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Provides a decision for a pending tool permission request.
    ///
    /// Wire method: `session.permissions.handlePendingPermissionRequest`.
    ///
    /// # Parameters
    ///
    /// * `params` - Pending permission request ID and the decision to apply (approve/reject and scope).
    ///
    /// # Returns
    ///
    /// Indicates whether the permission decision was applied; false when the request was already resolved.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_permission_request(
        &self,
        params: PermissionDecisionRequest,
    ) -> Result<PermissionRequestResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_HANDLEPENDINGPERMISSIONREQUEST,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reconstructs the set of pending tool permission requests from the session's event history.
    ///
    /// Wire method: `session.permissions.pendingRequests`.
    ///
    /// # Returns
    ///
    /// List of pending permission requests reconstructed from event history.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn pending_requests(&self) -> Result<PendingPermissionRequestList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_PENDINGREQUESTS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enables or disables automatic approval of tool permission requests for the session.
    ///
    /// Wire method: `session.permissions.setApproveAll`.
    ///
    /// # Parameters
    ///
    /// * `params` - Allow-all toggle for tool permission requests, with an optional telemetry source.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_approve_all(
        &self,
        params: PermissionsSetApproveAllRequest,
    ) -> Result<PermissionsSetApproveAllResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_SETAPPROVEALL,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.permissions.setMode`.
    ///
    /// # Parameters
    ///
    /// * `params` - Permission mode to apply for the session.
    ///
    /// # Returns
    ///
    /// Indicates whether the requested permission mode was applied and reports the authoritative post-mutation mode.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_mode(
        &self,
        params: PermissionsSetModeRequest,
    ) -> Result<PermissionsSetModeResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PERMISSIONS_SETMODE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the current permission mode for the session.
    ///
    /// Wire method: `session.permissions.getMode`.
    ///
    /// # Returns
    ///
    /// Current permission mode.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_mode(&self) -> Result<PermissionsGetModeResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PERMISSIONS_GETMODE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Adds or removes session-scoped or location-scoped permission rules.
    ///
    /// Wire method: `session.permissions.modifyRules`.
    ///
    /// # Parameters
    ///
    /// * `params` - Scope and add/remove instructions for modifying session- or location-scoped permission rules.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn modify_rules(
        &self,
        params: PermissionsModifyRulesParams,
    ) -> Result<PermissionsModifyRulesResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_MODIFYRULES,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Sets whether the client wants permission prompts bridged into session events.
    ///
    /// Wire method: `session.permissions.setRequired`.
    ///
    /// # Parameters
    ///
    /// * `params` - Toggles whether permission prompts should be bridged into session events for this client.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_required(
        &self,
        params: PermissionsSetRequiredRequest,
    ) -> Result<PermissionsSetRequiredResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_SETREQUIRED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Clears session-scoped tool permission approvals.
    ///
    /// Wire method: `session.permissions.resetSessionApprovals`.
    ///
    /// # Parameters
    ///
    /// * `params` - Clears session-scoped tool permission approvals, and optionally the location-scoped ones.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reset_session_approvals(
        &self,
        params: PermissionsResetSessionApprovalsRequest,
    ) -> Result<PermissionsResetSessionApprovalsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_RESETSESSIONAPPROVALS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Notifies the runtime that a permission prompt UI has been shown to the user.
    ///
    /// Wire method: `session.permissions.notifyPromptShown`.
    ///
    /// # Parameters
    ///
    /// * `params` - Notification payload describing the permission prompt that the client just rendered.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn notify_prompt_shown(
        &self,
        params: PermissionPromptShownNotification,
    ) -> Result<PermissionsNotifyPromptShownResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_NOTIFYPROMPTSHOWN,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.permissions.folderTrust.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcPermissionsFolderTrust<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcPermissionsFolderTrust<'a> {
    /// Reports whether a folder is trusted according to the user's folder trust state.
    ///
    /// Wire method: `session.permissions.folderTrust.isTrusted`.
    ///
    /// # Parameters
    ///
    /// * `params` - Folder path to check for trust.
    ///
    /// # Returns
    ///
    /// Folder trust check result.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn is_trusted(
        &self,
        params: FolderTrustCheckParams,
    ) -> Result<FolderTrustCheckResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_FOLDERTRUST_ISTRUSTED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Adds a folder to the user's trusted folders list.
    ///
    /// Wire method: `session.permissions.folderTrust.addTrusted`.
    ///
    /// # Parameters
    ///
    /// * `params` - Folder path to add to trusted folders.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add_trusted(
        &self,
        params: FolderTrustAddParams,
    ) -> Result<PermissionsFolderTrustAddTrustedResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_FOLDERTRUST_ADDTRUSTED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.permissions.locations.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcPermissionsLocations<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcPermissionsLocations<'a> {
    /// Resolves the permission location key and type for a working directory.
    ///
    /// Wire method: `session.permissions.locations.resolve`.
    ///
    /// # Parameters
    ///
    /// * `params` - Working directory to resolve into a location-permissions key.
    ///
    /// # Returns
    ///
    /// Resolved location-permissions key and type.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn resolve(
        &self,
        params: PermissionLocationResolveParams,
    ) -> Result<PermissionLocationResolveResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_LOCATIONS_RESOLVE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Applies persisted location-scoped tool approvals and allowed directories for a working directory to this session's permission service.
    ///
    /// Wire method: `session.permissions.locations.apply`.
    ///
    /// # Parameters
    ///
    /// * `params` - Working directory to load persisted location permissions for.
    ///
    /// # Returns
    ///
    /// Summary of persisted location permissions applied to the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn apply(
        &self,
        params: PermissionLocationApplyParams,
    ) -> Result<PermissionLocationApplyResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_LOCATIONS_APPLY,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Persists a tool approval for a permission location and applies its rules to this session's live permission service.
    ///
    /// Wire method: `session.permissions.locations.addToolApproval`.
    ///
    /// # Parameters
    ///
    /// * `params` - Location-scoped tool approval to persist.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add_tool_approval(
        &self,
        params: PermissionLocationAddToolApprovalParams,
    ) -> Result<PermissionsLocationsAddToolApprovalResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_LOCATIONS_ADDTOOLAPPROVAL,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.permissions.paths.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcPermissionsPaths<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcPermissionsPaths<'a> {
    /// Returns the session's allowed directories and primary working directory.
    ///
    /// Wire method: `session.permissions.paths.list`.
    ///
    /// # Returns
    ///
    /// Snapshot of the session's allow-listed directories and primary working directory.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<PermissionPathsList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_PATHS_LIST,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Adds a directory to the session's allow-list.
    ///
    /// Wire method: `session.permissions.paths.add`.
    ///
    /// # Parameters
    ///
    /// * `params` - Directory path to add to the session's allowed directories.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add(
        &self,
        params: PermissionPathsAddParams,
    ) -> Result<PermissionsPathsAddResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_PATHS_ADD,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Updates the session's primary working directory used by the permission policy.
    ///
    /// Wire method: `session.permissions.paths.updatePrimary`.
    ///
    /// # Parameters
    ///
    /// * `params` - Directory path to set as the session's new primary working directory.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update_primary(
        &self,
        params: PermissionPathsUpdatePrimaryParams,
    ) -> Result<PermissionsPathsUpdatePrimaryResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_PATHS_UPDATEPRIMARY,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reports whether a path falls within any of the session's allowed directories.
    ///
    /// Wire method: `session.permissions.paths.isPathWithinAllowedDirectories`.
    ///
    /// # Parameters
    ///
    /// * `params` - Path to evaluate against the session's allowed directories.
    ///
    /// # Returns
    ///
    /// Indicates whether the supplied path is within the session's allowed directories.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn is_path_within_allowed_directories(
        &self,
        params: PermissionPathsAllowedCheckParams,
    ) -> Result<PermissionPathsAllowedCheckResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_PATHS_ISPATHWITHINALLOWEDDIRECTORIES,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reports whether a path falls within the session's workspace (primary) directory.
    ///
    /// Wire method: `session.permissions.paths.isPathWithinWorkspace`.
    ///
    /// # Parameters
    ///
    /// * `params` - Path to evaluate against the session's workspace (primary) directory.
    ///
    /// # Returns
    ///
    /// Indicates whether the supplied path is within the session's workspace directory.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn is_path_within_workspace(
        &self,
        params: PermissionPathsWorkspaceCheckParams,
    ) -> Result<PermissionPathsWorkspaceCheckResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_PATHS_ISPATHWITHINWORKSPACE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.permissions.urls.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcPermissionsUrls<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcPermissionsUrls<'a> {
    /// Toggles the runtime's URL-permission policy between unrestricted and restricted modes.
    ///
    /// Wire method: `session.permissions.urls.setUnrestrictedMode`.
    ///
    /// # Parameters
    ///
    /// * `params` - Whether the URL-permission policy should run in unrestricted mode.
    ///
    /// # Returns
    ///
    /// Indicates whether the operation succeeded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_unrestricted_mode(
        &self,
        params: PermissionUrlsSetUnrestrictedModeParams,
    ) -> Result<PermissionsUrlsSetUnrestrictedModeResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PERMISSIONS_URLS_SETUNRESTRICTEDMODE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.plan.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcPlan<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcPlan<'a> {
    /// Reads the session plan file from the workspace.
    ///
    /// Wire method: `session.plan.read`.
    ///
    /// # Returns
    ///
    /// Existence, contents, and resolved path of the session plan file.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read(&self) -> Result<PlanReadResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PLAN_READ, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Writes new content to the session plan file.
    ///
    /// Wire method: `session.plan.update`.
    ///
    /// # Parameters
    ///
    /// * `params` - Replacement contents to write to the session plan file.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update(&self, params: PlanUpdateRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PLAN_UPDATE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Deletes the session plan file from the workspace.
    ///
    /// Wire method: `session.plan.delete`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn delete(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PLAN_DELETE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Reads todo rows from the session SQL database for plan rendering.
    ///
    /// Wire method: `session.plan.readSqlTodos`.
    ///
    /// # Returns
    ///
    /// Todo rows read from the session SQL database. Empty when no session database is available.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read_sql_todos(&self) -> Result<PlanReadSqlTodosResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PLAN_READSQLTODOS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.plan.readSqlTodosWithDependencies`.
    ///
    /// # Returns
    ///
    /// Todo rows + dependency edges read from the session SQL database.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read_sql_todos_with_dependencies(
        &self,
    ) -> Result<PlanReadSqlTodosWithDependenciesResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_PLAN_READSQLTODOSWITHDEPENDENCIES,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.plugins.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcPlugins<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcPlugins<'a> {
    /// Lists plugins installed for the session.
    ///
    /// Wire method: `session.plugins.list`.
    ///
    /// # Returns
    ///
    /// Plugins installed for the session, with their enabled state and version metadata.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<PluginList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PLUGINS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.plugins.reload`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PLUGINS_RELOAD, Some(wire_params))
            .await?;
        Ok(())
    }

    /// 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.
    ///
    /// Wire method: `session.plugins.reload`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional flags controlling which side effects the reload performs.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload_with_params(&self, params: PluginsReloadRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PLUGINS_RELOAD, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `session.provider.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcProvider<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcProvider<'a> {
    /// 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.
    ///
    /// Wire method: `session.provider.getEndpoint`.
    ///
    /// # Returns
    ///
    /// A snapshot of the provider endpoint the session is currently configured to talk to.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_endpoint(&self) -> Result<ProviderEndpoint, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PROVIDER_GETENDPOINT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.provider.getEndpoint`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional model identifier to scope the endpoint snapshot to.
    ///
    /// # Returns
    ///
    /// A snapshot of the provider endpoint the session is currently configured to talk to.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_endpoint_with_params(
        &self,
        params: ProviderGetEndpointRequest,
    ) -> Result<ProviderEndpoint, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PROVIDER_GETENDPOINT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.provider.add`.
    ///
    /// # Parameters
    ///
    /// * `params` - BYOK providers and/or models to add to the session's registry at runtime. Both fields are optional; provide providers, models, or both.
    ///
    /// # Returns
    ///
    /// The selectable model entries synthesized for the models added by this call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add(&self, params: ProviderAddRequest) -> Result<ProviderAddResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_PROVIDER_ADD, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.queue.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcQueue<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcQueue<'a> {
    /// Returns the local session's pending user-facing queued items and steering messages.
    ///
    /// Wire method: `session.queue.pendingItems`.
    ///
    /// # Returns
    ///
    /// Snapshot of the session's pending queued items and immediate-steering messages.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn pending_items(&self) -> Result<QueuePendingItemsResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_PENDINGITEMS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the internal native queue snapshot for in-process session orchestration.
    ///
    /// Wire method: `session.queue.snapshot`.
    ///
    /// # Returns
    ///
    /// Internal snapshot of native queue state for local session orchestration.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn snapshot(&self) -> Result<QueueSnapshotResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_SNAPSHOT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Moves an addressable queued item to a public visible position.
    ///
    /// Wire method: `session.queue.moveItem`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for moving a queued item by stable id.
    ///
    /// # Returns
    ///
    /// Result of moving a queued item.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn move_item(
        &self,
        params: QueueMoveItemRequest,
    ) -> Result<QueueMoveItemResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_MOVEITEM, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Inserts a new queued message at a public visible position.
    ///
    /// Wire method: `session.queue.insertAt`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for inserting a queued message at a public visible position.
    ///
    /// # Returns
    ///
    /// Result of inserting a queued message.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn insert_at(
        &self,
        params: QueueInsertAtRequest,
    ) -> Result<QueueInsertAtResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_INSERTAT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Removes an addressable queued item by its stable id.
    ///
    /// Wire method: `session.queue.removeAt`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for removing a queued item by stable id.
    ///
    /// # Returns
    ///
    /// Result of removing a queued item.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn remove_at(
        &self,
        params: QueueRemoveAtRequest,
    ) -> Result<QueueRemoveAtResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_REMOVEAT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Updates the text of an addressable single-message queue item.
    ///
    /// Wire method: `session.queue.updateText`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for editing a single queued message.
    ///
    /// # Returns
    ///
    /// Result of editing a queued message.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update_text(
        &self,
        params: QueueUpdateTextRequest,
    ) -> Result<QueueUpdateTextResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_UPDATETEXT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Duplicates an addressable queued item immediately after its source.
    ///
    /// Wire method: `session.queue.duplicateAt`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for duplicating a queued item.
    ///
    /// # Returns
    ///
    /// Result of duplicating a queued item.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn duplicate_at(
        &self,
        params: QueueDuplicateAtRequest,
    ) -> Result<QueueDuplicateAtResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_DUPLICATEAT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Acquires or releases the queued-lane drain pause.
    ///
    /// Wire method: `session.queue.setDrainPaused`.
    ///
    /// # Parameters
    ///
    /// * `params` - 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_drain_paused(&self, params: QueueSetDrainPausedRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_SETDRAINPAUSED, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Moves an addressable queued message into the live turn's steering lane.
    ///
    /// Wire method: `session.queue.sendNow`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for steering a queued message into a live turn.
    ///
    /// # Returns
    ///
    /// Result of trying to steer a queued message into a live turn.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn send_now(&self, params: QueueSendNowRequest) -> Result<QueueSendNowResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_SENDNOW, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reports whether the local session has native queued work pending.
    ///
    /// Wire method: `session.queue.hasPending`.
    ///
    /// # Returns
    ///
    /// Whether the native queue has pending work.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn has_pending(&self) -> Result<QueueHasPendingResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_HASPENDING, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Begins a native deferred-idle drain when background work has quiesced.
    ///
    /// Wire method: `session.queue.beginDeferredIdleDrain`.
    ///
    /// # Parameters
    ///
    /// * `params` - Inputs for starting a deferred-idle drain.
    ///
    /// # Returns
    ///
    /// Whether a deferred-idle drain should run.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn begin_deferred_idle_drain(
        &self,
        params: QueueBeginDeferredIdleDrainRequest,
    ) -> Result<QueueBeginDeferredIdleDrainResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_QUEUE_BEGINDEFERREDIDLEDRAIN,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Finishes a native deferred-idle drain and reports whether to drain queue work or emit idle.
    ///
    /// Wire method: `session.queue.finishDeferredIdleDrain`.
    ///
    /// # Parameters
    ///
    /// * `params` - Inputs for completing a deferred-idle drain.
    ///
    /// # Returns
    ///
    /// Action selected by the native deferred-idle drain.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn finish_deferred_idle_drain(
        &self,
        params: QueueFinishDeferredIdleDrainRequest,
    ) -> Result<QueueFinishDeferredIdleDrainResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_QUEUE_FINISHDEFERREDIDLEDRAIN,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Marks session.idle as deferred by native background work state.
    ///
    /// Wire method: `session.queue.deferSessionIdle`.
    ///
    /// # Parameters
    ///
    /// * `params` - Inputs for marking session.idle deferred in native state.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn defer_session_idle(
        &self,
        params: QueueDeferSessionIdleRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_QUEUE_DEFERSESSIONIDLE,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Removes the most recently queued user-facing item (LIFO).
    ///
    /// Wire method: `session.queue.removeMostRecent`.
    ///
    /// # Returns
    ///
    /// Indicates whether a user-facing pending item was removed.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn remove_most_recent(&self) -> Result<QueueRemoveMostRecentResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_QUEUE_REMOVEMOSTRECENT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Clears all pending queued items on the local session.
    ///
    /// Wire method: `session.queue.clear`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn clear(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_CLEAR, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Consumes queued native system notifications matching an internal filter.
    ///
    /// Wire method: `session.queue.consumeSystemNotifications`.
    ///
    /// # Parameters
    ///
    /// * `params` - Internal filter for consuming queued system notifications.
    ///
    /// # Returns
    ///
    /// Indicates whether a user-facing pending item was removed.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn consume_system_notifications(
        &self,
        params: QueueConsumeSystemNotificationsRequest,
    ) -> Result<QueueRemoveMostRecentResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_QUEUE_CONSUMESYSTEMNOTIFICATIONS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enqueues the internal resume-pending wake item when orphan handling needs a follow-up turn.
    ///
    /// Wire method: `session.queue.enqueueResumePending`.
    ///
    /// # Returns
    ///
    /// Result of enqueueing the resume-pending wake item.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn enqueue_resume_pending(
        &self,
    ) -> Result<QueueEnqueueResumePendingResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_QUEUE_ENQUEUERESUMEPENDING,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Drains the native local-session work queue for in-process session orchestration.
    ///
    /// Wire method: `session.queue.process`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn process(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_QUEUE_PROCESS, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `session.remote.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcRemote<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcRemote<'a> {
    /// Enables remote session export or steering.
    ///
    /// Wire method: `session.remote.enable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional remote session mode ("off", "export", or "on"); defaults to enabling both export and remote steering.
    ///
    /// # Returns
    ///
    /// GitHub URL for the session and a flag indicating whether remote steering is enabled.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enable(&self, params: RemoteEnableRequest) -> Result<RemoteEnableResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_REMOTE_ENABLE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Disables remote session export and steering.
    ///
    /// Wire method: `session.remote.disable`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn disable(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_REMOTE_DISABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Persists a remote-steerability change emitted by the host as a session event.
    ///
    /// Wire method: `session.remote.notifySteerableChanged`.
    ///
    /// # Parameters
    ///
    /// * `params` - New remote-steerability state to persist as a `session.remote_steerable_changed` event.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn notify_steerable_changed(
        &self,
        params: RemoteNotifySteerableChangedRequest,
    ) -> Result<RemoteNotifySteerableChangedResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_REMOTE_NOTIFYSTEERABLECHANGED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.schedule.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcSchedule<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcSchedule<'a> {
    /// Lists the session's currently active scheduled prompts.
    ///
    /// Wire method: `session.schedule.list`.
    ///
    /// # Returns
    ///
    /// Snapshot of the currently active recurring prompts for this session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<ScheduleList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SCHEDULE_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Hydrates the native schedule registry from persisted session events.
    ///
    /// Wire method: `session.schedule.hydrate`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn hydrate(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SCHEDULE_HYDRATE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Reports whether the session has an active self-paced scheduled prompt.
    ///
    /// Wire method: `session.schedule.hasSelfPaced`.
    ///
    /// # Returns
    ///
    /// Whether the session currently has an active self-paced schedule.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn has_self_paced(&self) -> Result<ScheduleHasSelfPacedResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_SCHEDULE_HASSELFPACED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers a relative-interval scheduled prompt.
    ///
    /// Wire method: `session.schedule.add`.
    ///
    /// # Parameters
    ///
    /// * `params` - Register a relative-interval scheduled prompt.
    ///
    /// # Returns
    ///
    /// Result of registering or re-arming a scheduled prompt.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn add(&self, params: ScheduleAddRequest) -> Result<ScheduleAddResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SCHEDULE_ADD, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers a recurring cron scheduled prompt.
    ///
    /// Wire method: `session.schedule.addCron`.
    ///
    /// # Parameters
    ///
    /// * `params` - Register a cron scheduled prompt.
    ///
    /// # Returns
    ///
    /// Result of registering or re-arming a scheduled prompt.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn add_cron(
        &self,
        params: ScheduleAddCronRequest,
    ) -> Result<ScheduleAddResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SCHEDULE_ADDCRON, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers an absolute-time scheduled prompt.
    ///
    /// Wire method: `session.schedule.addAt`.
    ///
    /// # Parameters
    ///
    /// * `params` - Register an absolute-time scheduled prompt.
    ///
    /// # Returns
    ///
    /// Result of registering or re-arming a scheduled prompt.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn add_at(
        &self,
        params: ScheduleAddAtRequest,
    ) -> Result<ScheduleAddResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SCHEDULE_ADDAT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers a self-paced scheduled prompt.
    ///
    /// Wire method: `session.schedule.addSelfPaced`.
    ///
    /// # Parameters
    ///
    /// * `params` - Register a self-paced scheduled prompt.
    ///
    /// # Returns
    ///
    /// Result of registering or re-arming a scheduled prompt.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn add_self_paced(
        &self,
        params: ScheduleAddSelfPacedRequest,
    ) -> Result<ScheduleAddResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_SCHEDULE_ADDSELFPACED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Re-arms an active self-paced scheduled prompt.
    ///
    /// Wire method: `session.schedule.rearmSelfPaced`.
    ///
    /// # Parameters
    ///
    /// * `params` - Re-arm a self-paced scheduled prompt.
    ///
    /// # Returns
    ///
    /// Result of registering or re-arming a scheduled prompt.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn rearm_self_paced(
        &self,
        params: ScheduleRearmSelfPacedRequest,
    ) -> Result<ScheduleAddResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_SCHEDULE_REARMSELFPACED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Removes a scheduled prompt by id.
    ///
    /// Wire method: `session.schedule.stop`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of the scheduled prompt to remove.
    ///
    /// # Returns
    ///
    /// Remove a scheduled prompt by id. The result entry is omitted if the id was unknown.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn stop(&self, params: ScheduleStopRequest) -> Result<ScheduleStopResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SCHEDULE_STOP, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.settings.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcSettings<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcSettings<'a> {
    /// 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.
    ///
    /// Wire method: `session.settings.snapshot`.
    ///
    /// # Returns
    ///
    /// Redacted, serializable view of session runtime settings for SDK boundary consumers. Secrets and raw feature flags are intentionally excluded.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn snapshot(&self) -> Result<SessionSettingsSnapshot, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SETTINGS_SNAPSHOT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.settings.evaluatePredicate`.
    ///
    /// # Parameters
    ///
    /// * `params` - Named Rust-owned settings predicate to evaluate for this session.
    ///
    /// # Returns
    ///
    /// Result of evaluating a Rust-owned settings predicate.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub(crate) async fn evaluate_predicate(
        &self,
        params: SessionSettingsEvaluatePredicateRequest,
    ) -> Result<SessionSettingsEvaluatePredicateResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_SETTINGS_EVALUATEPREDICATE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.shell.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcShell<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcShell<'a> {
    /// 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.
    ///
    /// Wire method: `session.shell.exec`.
    ///
    /// # Parameters
    ///
    /// * `params` - Shell command to run, with optional working directory and timeout in milliseconds.
    ///
    /// # Returns
    ///
    /// Identifier of the spawned process, used to correlate streamed output and exit notifications.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn exec(&self, params: ShellExecRequest) -> Result<ShellExecResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SHELL_EXEC, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.shell.kill`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of a process previously returned by "shell.exec" and the signal to send.
    ///
    /// # Returns
    ///
    /// Indicates whether the signal was delivered; false if the process was unknown or already exited.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn kill(&self, params: ShellKillRequest) -> Result<ShellKillResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SHELL_KILL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Executes a user-requested shell command through the session runtime.
    ///
    /// Wire method: `session.shell.executeUserRequested`.
    ///
    /// # Parameters
    ///
    /// * `params` - User-requested shell command and cancellation handle.
    ///
    /// # Returns
    ///
    /// Result of a user-requested shell command.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn execute_user_requested(
        &self,
        params: ShellExecuteUserRequestedRequest,
    ) -> Result<UserRequestedShellCommandResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_SHELL_EXECUTEUSERREQUESTED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Cancels a user-requested shell command by request ID.
    ///
    /// Wire method: `session.shell.cancelUserRequested`.
    ///
    /// # Parameters
    ///
    /// * `params` - User-requested shell execution cancellation handle.
    ///
    /// # Returns
    ///
    /// Cancellation result for a user-requested shell command.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn cancel_user_requested(
        &self,
        params: ShellCancelUserRequestedRequest,
    ) -> Result<CancelUserRequestedShellCommandResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_SHELL_CANCELUSERREQUESTED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.skills.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcSkills<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcSkills<'a> {
    /// Lists skills available to the session.
    ///
    /// Wire method: `session.skills.list`.
    ///
    /// # Returns
    ///
    /// Skills available to the session, with their enabled state.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<SkillList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SKILLS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the skills that have been invoked during this session.
    ///
    /// Wire method: `session.skills.getInvoked`.
    ///
    /// # Returns
    ///
    /// Skills invoked during this session, ordered by invocation time (most recent last).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_invoked(&self) -> Result<SkillsGetInvokedResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SKILLS_GETINVOKED, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Enables a skill for the session.
    ///
    /// Wire method: `session.skills.enable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name of the skill to enable for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn enable(&self, params: SkillsEnableRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SKILLS_ENABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Disables a skill for the session.
    ///
    /// Wire method: `session.skills.disable`.
    ///
    /// # Parameters
    ///
    /// * `params` - Name of the skill to disable for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn disable(&self, params: SkillsDisableRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SKILLS_DISABLE, Some(wire_params))
            .await?;
        Ok(())
    }

    /// Reloads skill definitions for the session.
    ///
    /// Wire method: `session.skills.reload`.
    ///
    /// # Returns
    ///
    /// Diagnostics from reloading skill definitions, with warnings and errors as separate lists.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn reload(&self) -> Result<SkillsLoadDiagnostics, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SKILLS_RELOAD, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Ensures the session's skill definitions have been loaded from disk.
    ///
    /// Wire method: `session.skills.ensureLoaded`.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn ensure_loaded(&self) -> Result<(), Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_SKILLS_ENSURELOADED, Some(wire_params))
            .await?;
        Ok(())
    }
}

/// `session.tasks.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcTasks<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcTasks<'a> {
    /// Starts a background agent task in the session.
    ///
    /// Wire method: `session.tasks.startAgent`.
    ///
    /// # Parameters
    ///
    /// * `params` - Agent type, prompt, name, and optional description and model override for the new task.
    ///
    /// # Returns
    ///
    /// Identifier assigned to the newly started background agent task.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn start_agent(
        &self,
        params: TasksStartAgentRequest,
    ) -> Result<TasksStartAgentResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_STARTAGENT, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists background tasks tracked by the session.
    ///
    /// Wire method: `session.tasks.list`.
    ///
    /// # Returns
    ///
    /// Background tasks currently tracked by the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list(&self) -> Result<TaskList, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_LIST, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Refreshes metadata for any detached background shells the runtime knows about.
    ///
    /// Wire method: `session.tasks.refresh`.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn refresh(&self) -> Result<TasksRefreshResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_REFRESH, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Waits for all in-flight background tasks and any follow-up turns to settle.
    ///
    /// Wire method: `session.tasks.waitForPending`.
    ///
    /// # 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).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn wait_for_pending(&self) -> Result<TasksWaitForPendingResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_WAITFORPENDING, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns progress information for a background task by ID.
    ///
    /// Wire method: `session.tasks.getProgress`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of the background task to fetch progress for.
    ///
    /// # Returns
    ///
    /// Progress information for the task, or null when no task with that ID is tracked.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_progress(
        &self,
        params: TasksGetProgressRequest,
    ) -> Result<TasksGetProgressResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_GETPROGRESS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the first sync-waiting task that can currently be promoted to background mode.
    ///
    /// Wire method: `session.tasks.getCurrentPromotable`.
    ///
    /// # Returns
    ///
    /// The first sync-waiting task that can currently be promoted to background mode.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_current_promotable(&self) -> Result<TasksGetCurrentPromotableResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TASKS_GETCURRENTPROMOTABLE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Promotes an eligible synchronously-waited task so it continues running in the background.
    ///
    /// Wire method: `session.tasks.promoteToBackground`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of the task to promote to background mode.
    ///
    /// # Returns
    ///
    /// Indicates whether the task was successfully promoted to background mode.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn promote_to_background(
        &self,
        params: TasksPromoteToBackgroundRequest,
    ) -> Result<TasksPromoteToBackgroundResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TASKS_PROMOTETOBACKGROUND,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Atomically promotes the first promotable sync-waiting task to background mode and returns it.
    ///
    /// Wire method: `session.tasks.promoteCurrentToBackground`.
    ///
    /// # Returns
    ///
    /// The promoted task as it now exists in background mode, omitted if no promotable task was waiting.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn promote_current_to_background(
        &self,
    ) -> Result<TasksPromoteCurrentToBackgroundResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TASKS_PROMOTECURRENTTOBACKGROUND,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Cancels a background task.
    ///
    /// Wire method: `session.tasks.cancel`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of the background task to cancel.
    ///
    /// # Returns
    ///
    /// Indicates whether the background task was successfully cancelled.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn cancel(&self, params: TasksCancelRequest) -> Result<TasksCancelResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_CANCEL, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Removes a completed or cancelled background task from tracking.
    ///
    /// Wire method: `session.tasks.remove`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of the completed or cancelled task to remove from tracking.
    ///
    /// # Returns
    ///
    /// Indicates whether the task was removed. False when the task does not exist or is still running/idle.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn remove(&self, params: TasksRemoveRequest) -> Result<TasksRemoveResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_REMOVE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Sends a message to a background agent task.
    ///
    /// Wire method: `session.tasks.sendMessage`.
    ///
    /// # Parameters
    ///
    /// * `params` - Identifier of the target agent task, message content, and optional sender agent ID.
    ///
    /// # Returns
    ///
    /// Indicates whether the message was delivered, with an error message when delivery failed.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn send_message(
        &self,
        params: TasksSendMessageRequest,
    ) -> Result<TasksSendMessageResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TASKS_SENDMESSAGE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.telemetry.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcTelemetry<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcTelemetry<'a> {
    /// Gets the telemetry engagement ID currently associated with the session, when available.
    ///
    /// Wire method: `session.telemetry.getEngagementId`.
    ///
    /// # Returns
    ///
    /// Telemetry engagement ID for the session, when available.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_engagement_id(&self) -> Result<SessionTelemetryEngagement, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TELEMETRY_GETENGAGEMENTID,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Sets feature override key/value pairs to attach to subsequent telemetry events for the session.
    ///
    /// Wire method: `session.telemetry.setFeatureOverrides`.
    ///
    /// # Parameters
    ///
    /// * `params` - Feature override key/value pairs to attach to subsequent telemetry events from this session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set_feature_overrides(
        &self,
        params: TelemetrySetFeatureOverridesRequest,
    ) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TELEMETRY_SETFEATUREOVERRIDES,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }
}

/// `session.tools.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcTools<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcTools<'a> {
    /// Executes one tool from the session's currently offered tool set through the native invocation pipeline.
    ///
    /// Wire method: `session.tools.execute`.
    ///
    /// # Parameters
    ///
    /// * `params` - A tool name and arguments to execute through the session's native invocation pipeline.
    ///
    /// # Returns
    ///
    /// Canonical result returned by a session tool.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn execute(&self, params: ToolsExecuteRequest) -> Result<ToolResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TOOLS_EXECUTE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns the Rust-owned built-in tool descriptors used to construct the session's offered tool set.
    ///
    /// Wire method: `session.tools.getBuiltinDescriptors`.
    ///
    /// # Parameters
    ///
    /// * `params` - Options controlling how Rust-owned built-in tool descriptors are materialized.
    ///
    /// # Returns
    ///
    /// Rust-owned built-in tool descriptors for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_builtin_descriptors(
        &self,
        params: ToolsGetBuiltinDescriptorsRequest,
    ) -> Result<ToolsGetBuiltinDescriptorsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TOOLS_GETBUILTINDESCRIPTORS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Projects a completed task_complete tool call into its label-safe session event payload.
    ///
    /// Wire method: `session.tools.taskCompleteEventData`.
    ///
    /// # Parameters
    ///
    /// * `params` - Task-completion tool arguments and final result used to build a label-safe session event payload.
    ///
    /// # Returns
    ///
    /// Task completion notification with summary from the agent
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn task_complete_event_data(
        &self,
        params: ToolsTaskCompleteEventDataRequest,
    ) -> Result<TaskCompleteData, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TOOLS_TASKCOMPLETEEVENTDATA,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Provides the result for a pending external tool call.
    ///
    /// Wire method: `session.tools.handlePendingToolCall`.
    ///
    /// # Parameters
    ///
    /// * `params` - Pending external tool call request ID, with the tool result or an error describing why it failed.
    ///
    /// # Returns
    ///
    /// Indicates whether the external tool call result was handled successfully.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_tool_call(
        &self,
        params: HandlePendingToolCallRequest,
    ) -> Result<HandlePendingToolCallResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TOOLS_HANDLEPENDINGTOOLCALL,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves, builds, and validates the runtime tool list for the session.
    ///
    /// Wire method: `session.tools.initializeAndValidate`.
    ///
    /// # 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.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn initialize_and_validate(&self) -> Result<ToolsInitializeAndValidateResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TOOLS_INITIALIZEANDVALIDATE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Returns lightweight metadata for the session's currently initialized tools.
    ///
    /// Wire method: `session.tools.getCurrentMetadata`.
    ///
    /// # Returns
    ///
    /// Current lightweight tool metadata snapshot for the session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_current_metadata(&self) -> Result<ToolsGetCurrentMetadataResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TOOLS_GETCURRENTMETADATA,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.tools.set`.
    ///
    /// # Parameters
    ///
    /// * `params` - Complete externally implemented tool list for the calling connection. An empty list removes every tool previously supplied by that connection.
    ///
    /// # Returns
    ///
    /// Empty result after replacing the calling connection's externally implemented tools.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set(&self, params: ToolsSetRequest) -> Result<ToolsSetResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_TOOLS_SET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Updates the current session's live subagent settings after user settings change. The persisted user settings remain the source of truth for future sessions.
    ///
    /// Wire method: `session.tools.updateSubagentSettings`.
    ///
    /// # Parameters
    ///
    /// * `params` - Subagent settings to apply to the current session
    ///
    /// # Returns
    ///
    /// Empty result after applying subagent settings
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update_subagent_settings(
        &self,
        params: UpdateSubagentSettingsRequest,
    ) -> Result<ToolsUpdateSubagentSettingsResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_TOOLS_UPDATESUBAGENTSETTINGS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.ui.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcUi<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcUi<'a> {
    /// Runs a transient no-tools model query against the current conversation context.
    ///
    /// Wire method: `session.ui.ephemeralQuery`.
    ///
    /// # Parameters
    ///
    /// * `params` - Transient question to answer without adding it to conversation history.
    ///
    /// # Returns
    ///
    /// Completed transient query. Ordered chunks and the terminal outcome are also delivered through `ui.ephemeral_query` session events while it runs.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn ephemeral_query(
        &self,
        params: UIEphemeralQueryRequest,
    ) -> Result<UIEphemeralQueryResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_UI_EPHEMERALQUERY, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Requests structured input from a UI-capable client.
    ///
    /// Wire method: `session.ui.elicitation`.
    ///
    /// # Parameters
    ///
    /// * `params` - Prompt message and JSON schema describing the form fields to elicit from the user.
    ///
    /// # Returns
    ///
    /// The elicitation response (accept with form values, decline, or cancel)
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn elicitation(
        &self,
        params: UIElicitationRequest,
    ) -> Result<UIElicitationResponse, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_UI_ELICITATION, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Provides the user response for a pending elicitation request.
    ///
    /// Wire method: `session.ui.handlePendingElicitation`.
    ///
    /// # Parameters
    ///
    /// * `params` - Pending elicitation request ID and the user's response (accept/decline/cancel + form values).
    ///
    /// # Returns
    ///
    /// Indicates whether the elicitation response was accepted; false if it was already resolved by another client.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_elicitation(
        &self,
        params: UIHandlePendingElicitationRequest,
    ) -> Result<UIElicitationResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_HANDLEPENDINGELICITATION,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves a pending `user_input.requested` event with the user's response.
    ///
    /// Wire method: `session.ui.handlePendingUserInput`.
    ///
    /// # Parameters
    ///
    /// * `params` - Request ID of a pending `user_input.requested` event and the user's response.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending UI request was resolved by this call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_user_input(
        &self,
        params: UIHandlePendingUserInputRequest,
    ) -> Result<UIHandlePendingResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_HANDLEPENDINGUSERINPUT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves a pending `sampling.requested` event with a sampling result, or rejects it.
    ///
    /// Wire method: `session.ui.handlePendingSampling`.
    ///
    /// # Parameters
    ///
    /// * `params` - Request ID of a pending `sampling.requested` event and an optional sampling result payload (omit to reject).
    ///
    /// # Returns
    ///
    /// Indicates whether the pending UI request was resolved by this call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_sampling(
        &self,
        params: UIHandlePendingSamplingRequest,
    ) -> Result<UIHandlePendingResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_HANDLEPENDINGSAMPLING,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves a pending `auto_mode_switch.requested` event with the user's accept/decline decision.
    ///
    /// Wire method: `session.ui.handlePendingAutoModeSwitch`.
    ///
    /// # Parameters
    ///
    /// * `params` - Request ID of a pending `auto_mode_switch.requested` event and the user's response.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending UI request was resolved by this call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_auto_mode_switch(
        &self,
        params: UIHandlePendingAutoModeSwitchRequest,
    ) -> Result<UIHandlePendingResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_HANDLEPENDINGAUTOMODESWITCH,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves a pending `session_limits_exhausted.requested` event with the user's selected limit action.
    ///
    /// Wire method: `session.ui.handlePendingSessionLimitsExhausted`.
    ///
    /// # Parameters
    ///
    /// * `params` - Request ID of a pending `session_limits_exhausted.requested` event and the user's selected limit action.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending UI request was resolved by this call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_session_limits_exhausted(
        &self,
        params: UIHandlePendingSessionLimitsExhaustedRequest,
    ) -> Result<UIHandlePendingResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_HANDLEPENDINGSESSIONLIMITSEXHAUSTED,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Resolves a pending `exit_plan_mode.requested` event with the user's response.
    ///
    /// Wire method: `session.ui.handlePendingExitPlanMode`.
    ///
    /// # Parameters
    ///
    /// * `params` - Request ID of a pending `exit_plan_mode.requested` event and the user's response.
    ///
    /// # Returns
    ///
    /// Indicates whether the pending UI request was resolved by this call.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn handle_pending_exit_plan_mode(
        &self,
        params: UIHandlePendingExitPlanModeRequest,
    ) -> Result<UIHandlePendingResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_HANDLEPENDINGEXITPLANMODE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Registers an in-process handler for auto-mode-switch requests so the server bridge skips dispatch.
    ///
    /// Wire method: `session.ui.registerDirectAutoModeSwitchHandler`.
    ///
    /// # 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).
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn register_direct_auto_mode_switch_handler(
        &self,
    ) -> Result<UIRegisterDirectAutoModeSwitchHandlerResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_REGISTERDIRECTAUTOMODESWITCHHANDLER,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Unregisters a previously-registered in-process auto-mode-switch handler by its opaque handle.
    ///
    /// Wire method: `session.ui.unregisterDirectAutoModeSwitchHandler`.
    ///
    /// # Parameters
    ///
    /// * `params` - Opaque handle previously returned by `registerDirectAutoModeSwitchHandler` to release.
    ///
    /// # Returns
    ///
    /// Indicates whether the handle was active and the registration count was decremented.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn unregister_direct_auto_mode_switch_handler(
        &self,
        params: UIUnregisterDirectAutoModeSwitchHandlerRequest,
    ) -> Result<UIUnregisterDirectAutoModeSwitchHandlerResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_UI_UNREGISTERDIRECTAUTOMODESWITCHHANDLER,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.usage.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcUsage<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcUsage<'a> {
    /// Gets accumulated usage metrics for the session.
    ///
    /// Wire method: `session.usage.getMetrics`.
    ///
    /// # Returns
    ///
    /// Accumulated session usage metrics, including premium request cost, token counts, model breakdown, and code-change totals.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_metrics(&self) -> Result<UsageGetMetricsResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_USAGE_GETMETRICS, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.visibility.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcVisibility<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcVisibility<'a> {
    /// 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").
    ///
    /// Wire method: `session.visibility.get`.
    ///
    /// # Returns
    ///
    /// Current sharing status and shareable GitHub URL for a session.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get(&self) -> Result<VisibilityGetResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_VISIBILITY_GET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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.
    ///
    /// Wire method: `session.visibility.set`.
    ///
    /// # Parameters
    ///
    /// * `params` - Desired sharing status for the session.
    ///
    /// # Returns
    ///
    /// Effective sharing status and shareable GitHub URL after updating session visibility.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn set(&self, params: VisibilitySetRequest) -> Result<VisibilitySetResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_VISIBILITY_SET, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}

/// `session.workspaces.*` RPCs.
#[derive(Clone, Copy)]
pub struct SessionRpcWorkspaces<'a> {
    pub(crate) session: &'a Session,
}

impl<'a> SessionRpcWorkspaces<'a> {
    /// Gets current workspace metadata for the session.
    ///
    /// Wire method: `session.workspaces.getWorkspace`.
    ///
    /// # Returns
    ///
    /// Current workspace metadata for the session, including its absolute filesystem path when available.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn get_workspace(&self) -> Result<WorkspacesGetWorkspaceResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_GETWORKSPACE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Updates workspace metadata for a local session and returns the refreshed workspace.
    ///
    /// Wire method: `session.workspaces.updateMetadata`.
    ///
    /// # Parameters
    ///
    /// * `params` - Workspace metadata fields to update.
    ///
    /// # Returns
    ///
    /// Current workspace metadata for the session, including its absolute filesystem path when available.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn update_metadata(
        &self,
        params: WorkspacesUpdateMetadataRequest,
    ) -> Result<WorkspacesGetWorkspaceResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_UPDATEMETADATA,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Ensures a local session workspace exists and returns it.
    ///
    /// Wire method: `session.workspaces.ensure`.
    ///
    /// # Parameters
    ///
    /// * `params` - Optional session context used when creating a local workspace.
    ///
    /// # Returns
    ///
    /// Current workspace metadata for the session, including its absolute filesystem path when available.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn ensure(
        &self,
        params: WorkspacesEnsureRequest,
    ) -> Result<WorkspacesGetWorkspaceResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_WORKSPACES_ENSURE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Lists files stored in the session workspace files directory.
    ///
    /// Wire method: `session.workspaces.listFiles`.
    ///
    /// # Returns
    ///
    /// Relative paths of files stored in the session workspace files directory.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_files(&self) -> Result<WorkspacesListFilesResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_WORKSPACES_LISTFILES, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reads a file from the session workspace files directory.
    ///
    /// Wire method: `session.workspaces.readFile`.
    ///
    /// # Parameters
    ///
    /// * `params` - Relative path of the workspace file to read.
    ///
    /// # Returns
    ///
    /// Contents of the requested workspace file as a UTF-8 string.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read_file(
        &self,
        params: WorkspacesReadFileRequest,
    ) -> Result<WorkspacesReadFileResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_WORKSPACES_READFILE, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Creates or overwrites a file in the session workspace files directory.
    ///
    /// Wire method: `session.workspaces.createFile`.
    ///
    /// # Parameters
    ///
    /// * `params` - Relative path and UTF-8 content for the workspace file to create or overwrite.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn create_file(&self, params: WorkspacesCreateFileRequest) -> Result<(), Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_CREATEFILE,
                Some(wire_params),
            )
            .await?;
        Ok(())
    }

    /// Lists workspace checkpoints in chronological order.
    ///
    /// Wire method: `session.workspaces.listCheckpoints`.
    ///
    /// # Returns
    ///
    /// Workspace checkpoints in chronological order; empty when the workspace is not enabled.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn list_checkpoints(&self) -> Result<WorkspacesListCheckpointsResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_LISTCHECKPOINTS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reads the content of a workspace checkpoint by number.
    ///
    /// Wire method: `session.workspaces.readCheckpoint`.
    ///
    /// # Parameters
    ///
    /// * `params` - Checkpoint number to read.
    ///
    /// # Returns
    ///
    /// Checkpoint content as a UTF-8 string, or null when the checkpoint or workspace is missing.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read_checkpoint(
        &self,
        params: WorkspacesReadCheckpointRequest,
    ) -> Result<WorkspacesReadCheckpointResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_READCHECKPOINT,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Adds a compaction summary checkpoint to the local session workspace.
    ///
    /// Wire method: `session.workspaces.addSummary`.
    ///
    /// # Parameters
    ///
    /// * `params` - Compaction summary checkpoint to persist.
    ///
    /// # Returns
    ///
    /// Persisted summary metadata and refreshed workspace metadata.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn add_summary(
        &self,
        params: WorkspacesAddSummaryRequest,
    ) -> Result<WorkspacesAddSummaryResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_ADDSUMMARY,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Truncates local workspace compaction summaries after a rollback.
    ///
    /// Wire method: `session.workspaces.truncateSummaries`.
    ///
    /// # Parameters
    ///
    /// * `params` - Rollback point for local workspace summaries.
    ///
    /// # Returns
    ///
    /// Current workspace metadata for the session, including its absolute filesystem path when available.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn truncate_summaries(
        &self,
        params: WorkspacesTruncateSummariesRequest,
    ) -> Result<WorkspacesGetWorkspaceResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_TRUNCATESUMMARIES,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Reads the autopilot objective state file from the local session workspace.
    ///
    /// Wire method: `session.workspaces.readAutopilotObjective`.
    ///
    /// # Returns
    ///
    /// Autopilot objective file content, or null when missing.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn read_autopilot_objective(
        &self,
    ) -> Result<WorkspacesReadAutopilotObjectiveResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_READAUTOPILOTOBJECTIVE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Writes the autopilot objective state file in the local session workspace.
    ///
    /// Wire method: `session.workspaces.writeAutopilotObjective`.
    ///
    /// # Parameters
    ///
    /// * `params` - Autopilot objective file content to persist.
    ///
    /// # Returns
    ///
    /// Result of writing the autopilot objective file.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn write_autopilot_objective(
        &self,
        params: WorkspacesWriteAutopilotObjectiveRequest,
    ) -> Result<WorkspacesWriteAutopilotObjectiveResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_WRITEAUTOPILOTOBJECTIVE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Deletes the autopilot objective state file from the local session workspace.
    ///
    /// Wire method: `session.workspaces.deleteAutopilotObjective`.
    ///
    /// # Returns
    ///
    /// Result of deleting the autopilot objective file.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn delete_autopilot_objective(
        &self,
    ) -> Result<WorkspacesDeleteAutopilotObjectiveResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_DELETEAUTOPILOTOBJECTIVE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Checks whether the local session workspace has an autopilot objective state file.
    ///
    /// Wire method: `session.workspaces.autopilotObjectiveExists`.
    ///
    /// # Returns
    ///
    /// Whether the autopilot objective file exists.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn autopilot_objective_exists(
        &self,
    ) -> Result<WorkspacesAutopilotObjectiveExistsResult, Error> {
        let wire_params = serde_json::json!({ "sessionId": self.session.id() });
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_AUTOPILOTOBJECTIVEEXISTS,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// Saves pasted content as a UTF-8 file in the session workspace.
    ///
    /// Wire method: `session.workspaces.saveLargePaste`.
    ///
    /// # Parameters
    ///
    /// * `params` - Pasted content to save as a UTF-8 file in the session workspace.
    ///
    /// # Returns
    ///
    /// Descriptor for the saved paste file, or null when the workspace is unavailable.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn save_large_paste(
        &self,
        params: WorkspacesSaveLargePasteRequest,
    ) -> Result<WorkspacesSaveLargePasteResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(
                rpc_methods::SESSION_WORKSPACES_SAVELARGEPASTE,
                Some(wire_params),
            )
            .await?;
        Ok(serde_json::from_value(_value)?)
    }

    /// 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`.
    ///
    /// Wire method: `session.workspaces.diff`.
    ///
    /// # Parameters
    ///
    /// * `params` - Parameters for computing a workspace diff.
    ///
    /// # Returns
    ///
    /// Workspace diff result for the requested mode.
    ///
    /// <div class="warning">
    ///
    /// **Experimental.** This API is part of an experimental wire-protocol surface
    /// and may change or be removed in future SDK or CLI releases. Pin both the
    /// SDK and CLI versions if your code depends on it.
    ///
    /// </div>
    pub async fn diff(&self, params: WorkspacesDiffRequest) -> Result<WorkspaceDiffResult, Error> {
        let mut wire_params = serde_json::to_value(params)?;
        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
        let _value = self
            .session
            .client()
            .call(rpc_methods::SESSION_WORKSPACES_DIFF, Some(wire_params))
            .await?;
        Ok(serde_json::from_value(_value)?)
    }
}