@github/copilot-sdk 0.2.2-preview.0 → 0.3.0-preview.0

package/dist/generated/rpc.d.ts

@@ -3,389 +3,671 @@
  * Generated from: api.schema.json
  */
 import type { MessageConnection } from "vscode-jsonrpc/node.js";
-export interface PingResult {
+/**
+ * Server transport type: stdio, http, sse, or memory (local configs are normalized to stdio)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "DiscoveredMcpServerType".
+ */
+export type DiscoveredMcpServerType = "stdio" | "http" | "sse" | "memory";
+/**
+ * Configuration source
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "DiscoveredMcpServerSource".
+ */
+export type DiscoveredMcpServerSource = "user" | "workspace" | "plugin" | "builtin";
+/**
+ * Discovery source: project (.github/extensions/) or user (~/.copilot/extensions/)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ExtensionSource".
+ */
+export type ExtensionSource = "project" | "user";
+/**
+ * Current status: running, disabled, failed, or starting
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ExtensionStatus".
+ */
+export type ExtensionStatus = "running" | "disabled" | "failed" | "starting";
+export type FilterMapping = {
+    [k: string]: FilterMappingValue;
+} | FilterMappingString;
+export type FilterMappingValue = "none" | "markdown" | "hidden_characters";
+export type FilterMappingString = "none" | "markdown" | "hidden_characters";
+/**
+ * Category of instruction source — used for merge logic
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "InstructionsSourcesType".
+ */
+export type InstructionsSourcesType = "home" | "repo" | "model" | "vscode" | "nested-agents" | "child-instructions";
+/**
+ * Where this source lives — used for UI grouping
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "InstructionsSourcesLocation".
+ */
+export type InstructionsSourcesLocation = "user" | "repository" | "working-directory";
+/**
+ * Log severity level. Determines how the message is displayed in the timeline. Defaults to "info".
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SessionLogLevel".
+ */
+export type SessionLogLevel = "info" | "warning" | "error";
+/**
+ * MCP server configuration (local/stdio or remote/http)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpServerConfig".
+ */
+export type McpServerConfig = McpServerConfigLocal | McpServerConfigHttp;
+export type McpServerConfigLocalType = "local" | "stdio";
+/**
+ * Remote transport type. Defaults to "http" when omitted.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpServerConfigHttpType".
+ */
+export type McpServerConfigHttpType = "http" | "sse";
+/**
+ * Connection status: connected, failed, needs-auth, pending, disabled, or not_configured
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpServerStatus".
+ */
+export type McpServerStatus = "connected" | "failed" | "needs-auth" | "pending" | "disabled" | "not_configured";
+/**
+ * Configuration source: user, workspace, plugin, or builtin
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpServerSource".
+ */
+export type McpServerSource = "user" | "workspace" | "plugin" | "builtin";
+/**
+ * The agent mode. Valid values: "interactive", "plan", "autopilot".
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SessionMode".
+ */
+export type SessionMode = "interactive" | "plan" | "autopilot";
+export type PermissionDecision = PermissionDecisionApproved | PermissionDecisionDeniedByRules | PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser | PermissionDecisionDeniedInteractivelyByUser | PermissionDecisionDeniedByContentExclusionPolicy | PermissionDecisionDeniedByPermissionRequestHook;
+/**
+ * Error classification
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SessionFsErrorCode".
+ */
+export type SessionFsErrorCode = "ENOENT" | "UNKNOWN";
+/**
+ * Entry type
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SessionFsReaddirWithTypesEntryType".
+ */
+export type SessionFsReaddirWithTypesEntryType = "file" | "directory";
+/**
+ * Path conventions used by this filesystem
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SessionFsSetProviderConventions".
+ */
+export type SessionFsSetProviderConventions = "windows" | "posix";
+/**
+ * Signal to send (default: SIGTERM)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ShellKillSignal".
+ */
+export type ShellKillSignal = "SIGTERM" | "SIGKILL" | "SIGINT";
+/**
+ * Tool call result (string or expanded result object)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ToolsHandlePendingToolCall".
+ */
+export type ToolsHandlePendingToolCall = string | ToolCallResult;
+export type UIElicitationFieldValue = string | number | boolean | string[];
+export type UIElicitationSchemaProperty = UIElicitationStringEnumField | UIElicitationStringOneOfField | UIElicitationArrayEnumField | UIElicitationArrayAnyOfField | UIElicitationSchemaPropertyBoolean | UIElicitationSchemaPropertyString | UIElicitationSchemaPropertyNumber;
+export type UIElicitationSchemaPropertyStringFormat = "email" | "uri" | "date" | "date-time";
+export type UIElicitationSchemaPropertyNumberType = "number" | "integer";
+/**
+ * The user's response: accept (submitted), decline (rejected), or cancel (dismissed)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UIElicitationResponseAction".
+ */
+export type UIElicitationResponseAction = "accept" | "decline" | "cancel";
+export interface AccountGetQuotaResult {
     /**
-     * Echoed message (or default greeting)
+     * Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)
      */
-    message: string;
+    quotaSnapshots: {
+        [k: string]: AccountQuotaSnapshot;
+    };
+}
+export interface AccountQuotaSnapshot {
     /**
-     * Server timestamp in milliseconds
+     * Whether the user has an unlimited usage entitlement
      */
-    timestamp: number;
+    isUnlimitedEntitlement: boolean;
     /**
-     * Server protocol version number
+     * Number of requests included in the entitlement
      */
-    protocolVersion: number;
+    entitlementRequests: number;
+    /**
+     * Number of requests used so far this period
+     */
+    usedRequests: number;
+    /**
+     * Whether usage is still permitted after quota exhaustion
+     */
+    usageAllowedWithExhaustedQuota: boolean;
+    /**
+     * Percentage of entitlement remaining
+     */
+    remainingPercentage: number;
+    /**
+     * Number of overage requests made this period
+     */
+    overage: number;
+    /**
+     * Whether overage is allowed when quota is exhausted
+     */
+    overageAllowedWithExhaustedQuota: boolean;
+    /**
+     * Date when the quota resets (ISO 8601 string)
+     */
+    resetDate?: string;
 }
-export interface PingParams {
+/** @experimental */
+export interface AgentGetCurrentResult {
     /**
-     * Optional message to echo back
+     * Currently selected custom agent, or null if using the default agent
      */
-    message?: string;
+    agent?: AgentInfo | null;
 }
-export interface ModelsListResult {
+export interface AgentInfo {
     /**
-     * List of available models with full metadata
+     * Unique identifier of the custom agent
      */
-    models: {
-        /**
-         * Model identifier (e.g., "claude-sonnet-4.5")
-         */
-        id: string;
-        /**
-         * Display name
-         */
-        name: string;
-        capabilities: ModelCapabilities;
-        /**
-         * Policy state (if applicable)
-         */
-        policy?: {
-            /**
-             * Current policy state for this model
-             */
-            state: string;
-            /**
-             * Usage terms or conditions for this model
-             */
-            terms: string;
-        };
-        /**
-         * Billing information
-         */
-        billing?: {
-            /**
-             * Billing cost multiplier relative to the base rate
-             */
-            multiplier: number;
-        };
-        /**
-         * Supported reasoning effort levels (only present if model supports reasoning effort)
-         */
-        supportedReasoningEfforts?: string[];
-        /**
-         * Default reasoning effort level (only present if model supports reasoning effort)
-         */
-        defaultReasoningEffort?: string;
-    }[];
+    name: string;
+    /**
+     * Human-readable display name
+     */
+    displayName: string;
+    /**
+     * Description of the agent's purpose
+     */
+    description: string;
 }
-/**
- * Model capabilities and limits
- */
-export interface ModelCapabilities {
-    supports: ModelCapabilitiesSupports;
-    limits: ModelCapabilitiesLimits;
+/** @experimental */
+export interface AgentList {
+    /**
+     * Available custom agents
+     */
+    agents: AgentInfo[];
 }
-/**
- * Feature flags indicating what the model supports
- */
-export interface ModelCapabilitiesSupports {
+/** @experimental */
+export interface AgentReloadResult {
     /**
-     * Whether this model supports vision/image input
+     * Reloaded custom agents
      */
-    vision?: boolean;
+    agents: AgentInfo[];
+}
+/** @experimental */
+export interface AgentSelectRequest {
     /**
-     * Whether this model supports reasoning effort configuration
+     * Name of the custom agent to select
      */
-    reasoningEffort?: boolean;
+    name: string;
 }
-/**
- * Token limits for prompts, outputs, and context window
- */
-export interface ModelCapabilitiesLimits {
+/** @experimental */
+export interface AgentSelectResult {
+    agent: AgentInfo;
+}
+export interface CommandsHandlePendingCommandRequest {
     /**
-     * Maximum number of prompt/input tokens
+     * Request ID from the command invocation event
      */
-    max_prompt_tokens?: number;
+    requestId: string;
     /**
-     * Maximum number of output/completion tokens
+     * Error message if the command handler failed
      */
-    max_output_tokens?: number;
+    error?: string;
+}
+export interface CommandsHandlePendingCommandResult {
     /**
-     * Maximum total context window size in tokens
+     * Whether the command was handled successfully
      */
-    max_context_window_tokens: number;
-    vision?: ModelCapabilitiesLimitsVision;
+    success: boolean;
+}
+export interface CurrentModel {
+    /**
+     * Currently active model identifier
+     */
+    modelId?: string;
+}
+export interface DiscoveredMcpServer {
+    /**
+     * Server name (config key)
+     */
+    name: string;
+    type?: DiscoveredMcpServerType;
+    source: DiscoveredMcpServerSource;
+    /**
+     * Whether the server is enabled (not in the disabled list)
+     */
+    enabled: boolean;
+}
+export interface Extension {
+    /**
+     * Source-qualified ID (e.g., 'project:my-ext', 'user:auth-helper')
+     */
+    id: string;
+    /**
+     * Extension name (directory name)
+     */
+    name: string;
+    source: ExtensionSource;
+    status: ExtensionStatus;
+    /**
+     * Process ID if the extension is running
+     */
+    pid?: number;
+}
+/** @experimental */
+export interface ExtensionList {
+    /**
+     * Discovered extensions and their current status
+     */
+    extensions: Extension[];
+}
+/** @experimental */
+export interface ExtensionsDisableRequest {
+    /**
+     * Source-qualified extension ID to disable
+     */
+    id: string;
+}
+/** @experimental */
+export interface ExtensionsEnableRequest {
+    /**
+     * Source-qualified extension ID to enable
+     */
+    id: string;
+}
+/** @experimental */
+export interface FleetStartRequest {
+    /**
+     * Optional user prompt to combine with fleet instructions
+     */
+    prompt?: string;
+}
+/** @experimental */
+export interface FleetStartResult {
+    /**
+     * Whether fleet mode was successfully activated
+     */
+    started: boolean;
+}
+export interface HandleToolCallResult {
+    /**
+     * Whether the tool call result was handled successfully
+     */
+    success: boolean;
 }
 /**
- * Vision-specific limits
+ * Post-compaction context window usage breakdown
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "HistoryCompactContextWindow".
  */
-export interface ModelCapabilitiesLimitsVision {
+export interface HistoryCompactContextWindow {
     /**
-     * MIME types the model accepts
+     * Maximum token count for the model's context window
      */
-    supported_media_types: string[];
+    tokenLimit: number;
     /**
-     * Maximum number of images per prompt
+     * Current total tokens in the context window (system + conversation + tool definitions)
      */
-    max_prompt_images: number;
+    currentTokens: number;
     /**
-     * Maximum image size in bytes
+     * Current number of messages in the conversation
      */
-    max_prompt_image_size: number;
+    messagesLength: number;
+    /**
+     * Token count from system message(s)
+     */
+    systemTokens?: number;
+    /**
+     * Token count from non-system messages (user, assistant, tool)
+     */
+    conversationTokens?: number;
+    /**
+     * Token count from tool definitions
+     */
+    toolDefinitionsTokens?: number;
 }
-export interface ToolsListResult {
+/** @experimental */
+export interface HistoryCompactResult {
     /**
-     * List of available built-in tools with metadata
+     * Whether compaction completed successfully
      */
-    tools: {
-        /**
-         * Tool identifier (e.g., "bash", "grep", "str_replace_editor")
-         */
-        name: string;
-        /**
-         * Optional namespaced name for declarative filtering (e.g., "playwright/navigate" for MCP tools)
-         */
-        namespacedName?: string;
-        /**
-         * Description of what the tool does
-         */
-        description: string;
-        /**
-         * JSON Schema for the tool's input parameters
-         */
-        parameters?: {
-            [k: string]: unknown;
-        };
-        /**
-         * Optional instructions for how to use this tool effectively
-         */
-        instructions?: string;
-    }[];
+    success: boolean;
+    /**
+     * Number of tokens freed by compaction
+     */
+    tokensRemoved: number;
+    /**
+     * Number of messages removed during compaction
+     */
+    messagesRemoved: number;
+    contextWindow?: HistoryCompactContextWindow;
 }
-export interface ToolsListParams {
+/** @experimental */
+export interface HistoryTruncateRequest {
     /**
-     * Optional model ID — when provided, the returned tool list reflects model-specific overrides
+     * Event ID to truncate to. This event and all events after it are removed from the session.
      */
-    model?: string;
+    eventId: string;
 }
-export interface AccountGetQuotaResult {
+/** @experimental */
+export interface HistoryTruncateResult {
     /**
-     * Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)
+     * Number of events that were removed
      */
-    quotaSnapshots: {
-        [k: string]: {
-            /**
-             * Number of requests included in the entitlement
-             */
-            entitlementRequests: number;
-            /**
-             * Number of requests used so far this period
-             */
-            usedRequests: number;
-            /**
-             * Percentage of entitlement remaining
-             */
-            remainingPercentage: number;
-            /**
-             * Number of overage requests made this period
-             */
-            overage: number;
-            /**
-             * Whether pay-per-request usage is allowed when quota is exhausted
-             */
-            overageAllowedWithExhaustedQuota: boolean;
-            /**
-             * Date when the quota resets (ISO 8601)
-             */
-            resetDate?: string;
-        };
+    eventsRemoved: number;
+}
+export interface InstructionsGetSourcesResult {
+    /**
+     * Instruction sources for the session
+     */
+    sources: InstructionsSources[];
+}
+export interface InstructionsSources {
+    /**
+     * Unique identifier for this source (used for toggling)
+     */
+    id: string;
+    /**
+     * Human-readable label
+     */
+    label: string;
+    /**
+     * File path relative to repo or absolute for home
+     */
+    sourcePath: string;
+    /**
+     * Raw content of the instruction file
+     */
+    content: string;
+    type: InstructionsSourcesType;
+    location: InstructionsSourcesLocation;
+    /**
+     * Glob pattern from frontmatter — when set, this instruction applies only to matching files
+     */
+    applyTo?: string;
+    /**
+     * Short description (body after frontmatter) for use in instruction tables
+     */
+    description?: string;
+}
+export interface LogRequest {
+    /**
+     * Human-readable message
+     */
+    message: string;
+    level?: SessionLogLevel;
+    /**
+     * When true, the message is transient and not persisted to the session event log on disk
+     */
+    ephemeral?: boolean;
+    /**
+     * Optional URL the user can open in their browser for more details
+     */
+    url?: string;
+}
+export interface LogResult {
+    /**
+     * The unique identifier of the emitted session event
+     */
+    eventId: string;
+}
+export interface McpConfigAddRequest {
+    /**
+     * Unique name for the MCP server
+     */
+    name: string;
+    config: McpServerConfig;
+}
+export interface McpServerConfigLocal {
+    /**
+     * Tools to include. Defaults to all tools if not specified.
+     */
+    tools?: string[];
+    type?: McpServerConfigLocalType;
+    isDefaultServer?: boolean;
+    filterMapping?: FilterMapping;
+    /**
+     * Timeout in milliseconds for tool calls to this server.
+     */
+    timeout?: number;
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: {
+        [k: string]: string;
+    };
+}
+export interface McpServerConfigHttp {
+    /**
+     * Tools to include. Defaults to all tools if not specified.
+     */
+    tools?: string[];
+    type?: McpServerConfigHttpType;
+    isDefaultServer?: boolean;
+    filterMapping?: FilterMapping;
+    /**
+     * Timeout in milliseconds for tool calls to this server.
+     */
+    timeout?: number;
+    url: string;
+    headers?: {
+        [k: string]: string;
     };
+    oauthClientId?: string;
+    oauthPublicClient?: boolean;
 }
-export interface McpConfigListResult {
+export interface McpConfigList {
     /**
      * All MCP servers from user config, keyed by name
      */
     servers: {
-        /**
-         * MCP server configuration (local/stdio or remote/http)
-         */
-        [k: string]: {
-            /**
-             * Tools to include. Defaults to all tools if not specified.
-             */
-            tools?: string[];
-            type?: "local" | "stdio";
-            isDefaultServer?: boolean;
-            filterMapping?: {
-                [k: string]: "none" | "markdown" | "hidden_characters";
-            } | ("none" | "markdown" | "hidden_characters");
-            timeout?: number;
-            command: string;
-            args: string[];
-            cwd?: string;
-            env?: {
-                [k: string]: string;
-            };
-        } | {
-            /**
-             * Tools to include. Defaults to all tools if not specified.
-             */
-            tools?: string[];
-            type: "http" | "sse";
-            isDefaultServer?: boolean;
-            filterMapping?: {
-                [k: string]: "none" | "markdown" | "hidden_characters";
-            } | ("none" | "markdown" | "hidden_characters");
-            timeout?: number;
-            url: string;
-            headers?: {
-                [k: string]: string;
-            };
-            oauthClientId?: string;
-            oauthPublicClient?: boolean;
-        };
+        [k: string]: McpServerConfig;
     };
 }
-export interface McpConfigAddParams {
+export interface McpConfigRemoveRequest {
     /**
-     * Unique name for the MCP server
+     * Name of the MCP server to remove
      */
     name: string;
-    /**
-     * MCP server configuration (local/stdio or remote/http)
-     */
-    config: {
-        /**
-         * Tools to include. Defaults to all tools if not specified.
-         */
-        tools?: string[];
-        type?: "local" | "stdio";
-        isDefaultServer?: boolean;
-        filterMapping?: {
-            [k: string]: "none" | "markdown" | "hidden_characters";
-        } | ("none" | "markdown" | "hidden_characters");
-        timeout?: number;
-        command: string;
-        args: string[];
-        cwd?: string;
-        env?: {
-            [k: string]: string;
-        };
-    } | {
-        /**
-         * Tools to include. Defaults to all tools if not specified.
-         */
-        tools?: string[];
-        type: "http" | "sse";
-        isDefaultServer?: boolean;
-        filterMapping?: {
-            [k: string]: "none" | "markdown" | "hidden_characters";
-        } | ("none" | "markdown" | "hidden_characters");
-        timeout?: number;
-        url: string;
-        headers?: {
-            [k: string]: string;
-        };
-        oauthClientId?: string;
-        oauthPublicClient?: boolean;
-    };
 }
-export interface McpConfigUpdateParams {
+export interface McpConfigUpdateRequest {
     /**
      * Name of the MCP server to update
      */
     name: string;
+    config: McpServerConfig;
+}
+/** @experimental */
+export interface McpDisableRequest {
     /**
-     * MCP server configuration (local/stdio or remote/http)
-     */
-    config: {
-        /**
-         * Tools to include. Defaults to all tools if not specified.
-         */
-        tools?: string[];
-        type?: "local" | "stdio";
-        isDefaultServer?: boolean;
-        filterMapping?: {
-            [k: string]: "none" | "markdown" | "hidden_characters";
-        } | ("none" | "markdown" | "hidden_characters");
-        timeout?: number;
-        command: string;
-        args: string[];
-        cwd?: string;
-        env?: {
-            [k: string]: string;
-        };
-    } | {
-        /**
-         * Tools to include. Defaults to all tools if not specified.
-         */
-        tools?: string[];
-        type: "http" | "sse";
-        isDefaultServer?: boolean;
-        filterMapping?: {
-            [k: string]: "none" | "markdown" | "hidden_characters";
-        } | ("none" | "markdown" | "hidden_characters");
-        timeout?: number;
-        url: string;
-        headers?: {
-            [k: string]: string;
-        };
-        oauthClientId?: string;
-        oauthPublicClient?: boolean;
-    };
+     * Name of the MCP server to disable
+     */
+    serverName: string;
 }
-export interface McpConfigRemoveParams {
+export interface McpDiscoverRequest {
     /**
-     * Name of the MCP server to remove
+     * Working directory used as context for discovery (e.g., plugin resolution)
+     */
+    workingDirectory?: string;
+}
+export interface McpDiscoverResult {
+    /**
+     * MCP servers discovered from all sources
+     */
+    servers: DiscoveredMcpServer[];
+}
+/** @experimental */
+export interface McpEnableRequest {
+    /**
+     * Name of the MCP server to enable
+     */
+    serverName: string;
+}
+export interface McpServer {
+    /**
+     * Server name (config key)
      */
     name: string;
+    status: McpServerStatus;
+    source?: McpServerSource;
+    /**
+     * Error message if the server failed to connect
+     */
+    error?: string;
 }
-export interface SessionFsSetProviderResult {
+/** @experimental */
+export interface McpServerList {
     /**
-     * Whether the provider was set successfully
+     * Configured MCP servers
      */
-    success: boolean;
+    servers: McpServer[];
 }
-export interface SessionFsSetProviderParams {
+export interface Model {
     /**
-     * Initial working directory for sessions
+     * Model identifier (e.g., "claude-sonnet-4.5")
      */
-    initialCwd: string;
+    id: string;
     /**
-     * Path within each session's SessionFs where the runtime stores files for that session
+     * Display name
      */
-    sessionStatePath: string;
+    name: string;
+    capabilities: ModelCapabilities;
+    policy?: ModelPolicy;
+    billing?: ModelBilling;
+    /**
+     * Supported reasoning effort levels (only present if model supports reasoning effort)
+     */
+    supportedReasoningEfforts?: string[];
     /**
-     * Path conventions used by this filesystem
+     * Default reasoning effort level (only present if model supports reasoning effort)
      */
-    conventions: "windows" | "posix";
+    defaultReasoningEffort?: string;
+}
+/**
+ * Model capabilities and limits
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelCapabilities".
+ */
+export interface ModelCapabilities {
+    supports?: ModelCapabilitiesSupports;
+    limits?: ModelCapabilitiesLimits;
 }
-export interface SessionModelGetCurrentResult {
+/**
+ * Feature flags indicating what the model supports
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelCapabilitiesSupports".
+ */
+export interface ModelCapabilitiesSupports {
     /**
-     * Currently active model identifier
+     * Whether this model supports vision/image input
      */
-    modelId?: string;
+    vision?: boolean;
+    /**
+     * Whether this model supports reasoning effort configuration
+     */
+    reasoningEffort?: boolean;
 }
-export interface SessionModelGetCurrentParams {
+/**
+ * Token limits for prompts, outputs, and context window
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelCapabilitiesLimits".
+ */
+export interface ModelCapabilitiesLimits {
     /**
-     * Target session identifier
+     * Maximum number of prompt/input tokens
      */
-    sessionId: string;
+    max_prompt_tokens?: number;
+    /**
+     * Maximum number of output/completion tokens
+     */
+    max_output_tokens?: number;
+    /**
+     * Maximum total context window size in tokens
+     */
+    max_context_window_tokens?: number;
+    vision?: ModelCapabilitiesLimitsVision;
 }
-export interface SessionModelSwitchToResult {
+/**
+ * Vision-specific limits
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelCapabilitiesLimitsVision".
+ */
+export interface ModelCapabilitiesLimitsVision {
     /**
-     * Currently active model identifier after the switch
+     * MIME types the model accepts
      */
-    modelId?: string;
+    supported_media_types: string[];
+    /**
+     * Maximum number of images per prompt
+     */
+    max_prompt_images: number;
+    /**
+     * Maximum image size in bytes
+     */
+    max_prompt_image_size: number;
 }
-export interface SessionModelSwitchToParams {
+/**
+ * Policy state (if applicable)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelPolicy".
+ */
+export interface ModelPolicy {
     /**
-     * Target session identifier
+     * Current policy state for this model
      */
-    sessionId: string;
+    state: string;
     /**
-     * Model identifier to switch to
+     * Usage terms or conditions for this model
      */
-    modelId: string;
+    terms: string;
+}
+/**
+ * Billing information
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelBilling".
+ */
+export interface ModelBilling {
     /**
-     * Reasoning effort level to use for the model
+     * Billing cost multiplier relative to the base rate
      */
-    reasoningEffort?: string;
-    modelCapabilities?: ModelCapabilitiesOverride;
+    multiplier: number;
 }
 /**
  * Override individual model capabilities resolved by the runtime
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelCapabilitiesOverride".
  */
 export interface ModelCapabilitiesOverride {
     supports?: ModelCapabilitiesOverrideSupports;
@@ -393,6 +675,9 @@ export interface ModelCapabilitiesOverride {
 }
 /**
  * Feature flags indicating what the model supports
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelCapabilitiesOverrideSupports".
  */
 export interface ModelCapabilitiesOverrideSupports {
     vision?: boolean;
@@ -400,6 +685,9 @@ export interface ModelCapabilitiesOverrideSupports {
 }
 /**
  * Token limits for prompts, outputs, and context window
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ModelCapabilitiesOverrideLimits".
  */
 export interface ModelCapabilitiesOverrideLimits {
     max_prompt_tokens?: number;
@@ -424,35 +712,138 @@ export interface ModelCapabilitiesOverrideLimitsVision {
      */
     max_prompt_image_size?: number;
 }
-export interface SessionModeGetResult {
+export interface ModelList {
     /**
-     * The current agent mode.
+     * List of available models with full metadata
      */
-    mode: "interactive" | "plan" | "autopilot";
+    models: Model[];
 }
-export interface SessionModeGetParams {
+export interface ModelSwitchToRequest {
     /**
-     * Target session identifier
+     * Model identifier to switch to
      */
-    sessionId: string;
+    modelId: string;
+    /**
+     * Reasoning effort level to use for the model
+     */
+    reasoningEffort?: string;
+    modelCapabilities?: ModelCapabilitiesOverride;
+}
+export interface ModelSwitchToResult {
+    /**
+     * Currently active model identifier after the switch
+     */
+    modelId?: string;
+}
+export interface ModeSetRequest {
+    mode: SessionMode;
+}
+export interface NameGetResult {
+    /**
+     * The session name, falling back to the auto-generated summary, or null if neither exists
+     */
+    name: string | null;
+}
+export interface NameSetRequest {
+    /**
+     * New session name (1–100 characters, trimmed of leading/trailing whitespace)
+     */
+    name: string;
+}
+export interface PermissionDecisionApproved {
+    /**
+     * The permission request was approved
+     */
+    kind: "approved";
+}
+export interface PermissionDecisionDeniedByRules {
+    /**
+     * Denied because approval rules explicitly blocked it
+     */
+    kind: "denied-by-rules";
+    /**
+     * Rules that denied the request
+     */
+    rules: unknown[];
 }
-export interface SessionModeSetResult {
+export interface PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser {
     /**
-     * The agent mode after switching.
+     * Denied because no approval rule matched and user confirmation was unavailable
      */
-    mode: "interactive" | "plan" | "autopilot";
+    kind: "denied-no-approval-rule-and-could-not-request-from-user";
+}
+export interface PermissionDecisionDeniedInteractivelyByUser {
+    /**
+     * Denied by the user during an interactive prompt
+     */
+    kind: "denied-interactively-by-user";
+    /**
+     * Optional feedback from the user explaining the denial
+     */
+    feedback?: string;
+}
+export interface PermissionDecisionDeniedByContentExclusionPolicy {
+    /**
+     * Denied by the organization's content exclusion policy
+     */
+    kind: "denied-by-content-exclusion-policy";
+    /**
+     * File path that triggered the exclusion
+     */
+    path: string;
+    /**
+     * Human-readable explanation of why the path was excluded
+     */
+    message: string;
 }
-export interface SessionModeSetParams {
+export interface PermissionDecisionDeniedByPermissionRequestHook {
+    /**
+     * Denied by a permission request hook registered by an extension or plugin
+     */
+    kind: "denied-by-permission-request-hook";
+    /**
+     * Optional message from the hook explaining the denial
+     */
+    message?: string;
+    /**
+     * Whether to interrupt the current agent turn
+     */
+    interrupt?: boolean;
+}
+export interface PermissionDecisionRequest {
+    /**
+     * Request ID of the pending permission request
+     */
+    requestId: string;
+    result: PermissionDecision;
+}
+export interface PermissionRequestResult {
+    /**
+     * Whether the permission request was handled successfully
+     */
+    success: boolean;
+}
+export interface PingRequest {
+    /**
+     * Optional message to echo back
+     */
+    message?: string;
+}
+export interface PingResult {
+    /**
+     * Echoed message (or default greeting)
+     */
+    message: string;
     /**
-     * Target session identifier
+     * Server timestamp in milliseconds
      */
-    sessionId: string;
+    timestamp: number;
     /**
-     * The mode to switch to. Valid values: "interactive", "plan", "autopilot".
+     * Server protocol version number
      */
-    mode: "interactive" | "plan" | "autopilot";
+    protocolVersion: number;
 }
-export interface SessionPlanReadResult {
+export interface PlanReadResult {
     /**
      * Whether the plan file exists in the workspace
      */
@@ -466,1070 +857,907 @@ export interface SessionPlanReadResult {
      */
     path: string | null;
 }
-export interface SessionPlanReadParams {
+export interface PlanUpdateRequest {
     /**
-     * Target session identifier
+     * The new content for the plan file
      */
-    sessionId: string;
-}
-export interface SessionPlanUpdateResult {
+    content: string;
 }
-export interface SessionPlanUpdateParams {
+export interface Plugin {
     /**
-     * Target session identifier
+     * Plugin name
      */
-    sessionId: string;
+    name: string;
     /**
-     * The new content for the plan file
+     * Marketplace the plugin came from
      */
-    content: string;
-}
-export interface SessionPlanDeleteResult {
-}
-export interface SessionPlanDeleteParams {
+    marketplace: string;
     /**
-     * Target session identifier
+     * Installed version
      */
-    sessionId: string;
-}
-export interface SessionWorkspaceListFilesResult {
+    version?: string;
     /**
-     * Relative file paths in the workspace files directory
+     * Whether the plugin is currently enabled
      */
-    files: string[];
+    enabled: boolean;
 }
-export interface SessionWorkspaceListFilesParams {
+/** @experimental */
+export interface PluginList {
     /**
-     * Target session identifier
+     * Installed plugins
      */
-    sessionId: string;
+    plugins: Plugin[];
 }
-export interface SessionWorkspaceReadFileResult {
+export interface ServerSkill {
     /**
-     * File content as a UTF-8 string
+     * Unique identifier for the skill
      */
-    content: string;
-}
-export interface SessionWorkspaceReadFileParams {
+    name: string;
     /**
-     * Target session identifier
+     * Description of what the skill does
      */
-    sessionId: string;
+    description: string;
     /**
-     * Relative path within the workspace files directory
+     * Source location type (e.g., project, personal-copilot, plugin, builtin)
      */
-    path: string;
-}
-export interface SessionWorkspaceCreateFileResult {
-}
-export interface SessionWorkspaceCreateFileParams {
+    source: string;
     /**
-     * Target session identifier
+     * Whether the skill can be invoked by the user as a slash command
      */
-    sessionId: string;
+    userInvocable: boolean;
     /**
-     * Relative path within the workspace files directory
+     * Whether the skill is currently enabled (based on global config)
      */
-    path: string;
+    enabled: boolean;
     /**
-     * File content to write as a UTF-8 string
+     * Absolute path to the skill file
      */
-    content: string;
+    path?: string;
+    /**
+     * The project path this skill belongs to (only for project/inherited skills)
+     */
+    projectPath?: string;
 }
-/** @experimental */
-export interface SessionFleetStartResult {
+export interface ServerSkillList {
     /**
-     * Whether fleet mode was successfully activated
+     * All discovered skills across all sources
      */
-    started: boolean;
+    skills: ServerSkill[];
 }
-/** @experimental */
-export interface SessionFleetStartParams {
+export interface SessionFsAppendFileRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
     /**
-     * Optional user prompt to combine with fleet instructions
+     * Path using SessionFs conventions
      */
-    prompt?: string;
-}
-/** @experimental */
-export interface SessionAgentListResult {
+    path: string;
     /**
-     * Available custom agents
+     * Content to append
      */
-    agents: {
-        /**
-         * Unique identifier of the custom agent
-         */
-        name: string;
-        /**
-         * Human-readable display name
-         */
-        displayName: string;
-        /**
-         * Description of the agent's purpose
-         */
-        description: string;
-    }[];
-}
-/** @experimental */
-export interface SessionAgentListParams {
+    content: string;
     /**
-     * Target session identifier
+     * Optional POSIX-style mode for newly created files
      */
-    sessionId: string;
+    mode?: number;
 }
-/** @experimental */
-export interface SessionAgentGetCurrentResult {
+/**
+ * Describes a filesystem error.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "SessionFsError".
+ */
+export interface SessionFsError {
+    code: SessionFsErrorCode;
     /**
-     * Currently selected custom agent, or null if using the default agent
+     * Free-form detail about the error, for logging/diagnostics
      */
-    agent: {
-        /**
-         * Unique identifier of the custom agent
-         */
-        name: string;
-        /**
-         * Human-readable display name
-         */
-        displayName: string;
-        /**
-         * Description of the agent's purpose
-         */
-        description: string;
-    } | null;
+    message?: string;
 }
-/** @experimental */
-export interface SessionAgentGetCurrentParams {
+export interface SessionFsExistsRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
+    /**
+     * Path using SessionFs conventions
+     */
+    path: string;
 }
-/** @experimental */
-export interface SessionAgentSelectResult {
+export interface SessionFsExistsResult {
     /**
-     * The newly selected custom agent
+     * Whether the path exists
      */
-    agent: {
-        /**
-         * Unique identifier of the custom agent
-         */
-        name: string;
-        /**
-         * Human-readable display name
-         */
-        displayName: string;
-        /**
-         * Description of the agent's purpose
-         */
-        description: string;
-    };
+    exists: boolean;
 }
-/** @experimental */
-export interface SessionAgentSelectParams {
+export interface SessionFsMkdirRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
     /**
-     * Name of the custom agent to select
+     * Path using SessionFs conventions
      */
-    name: string;
-}
-/** @experimental */
-export interface SessionAgentDeselectResult {
-}
-/** @experimental */
-export interface SessionAgentDeselectParams {
+    path: string;
     /**
-     * Target session identifier
+     * Create parent directories as needed
      */
-    sessionId: string;
-}
-/** @experimental */
-export interface SessionAgentReloadResult {
+    recursive?: boolean;
     /**
-     * Reloaded custom agents
+     * Optional POSIX-style mode for newly created directories
      */
-    agents: {
-        /**
-         * Unique identifier of the custom agent
-         */
-        name: string;
-        /**
-         * Human-readable display name
-         */
-        displayName: string;
-        /**
-         * Description of the agent's purpose
-         */
-        description: string;
-    }[];
+    mode?: number;
 }
-/** @experimental */
-export interface SessionAgentReloadParams {
+export interface SessionFsReaddirRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
-}
-/** @experimental */
-export interface SessionSkillsListResult {
     /**
-     * Available skills
+     * Path using SessionFs conventions
      */
-    skills: {
-        /**
-         * Unique identifier for the skill
-         */
-        name: string;
-        /**
-         * Description of what the skill does
-         */
-        description: string;
-        /**
-         * Source location type (e.g., project, personal, plugin)
-         */
-        source: string;
-        /**
-         * Whether the skill can be invoked by the user as a slash command
-         */
-        userInvocable: boolean;
-        /**
-         * Whether the skill is currently enabled
-         */
-        enabled: boolean;
-        /**
-         * Absolute path to the skill file
-         */
-        path?: string;
-    }[];
+    path: string;
 }
-/** @experimental */
-export interface SessionSkillsListParams {
+export interface SessionFsReaddirResult {
     /**
-     * Target session identifier
+     * Entry names in the directory
      */
-    sessionId: string;
-}
-/** @experimental */
-export interface SessionSkillsEnableResult {
+    entries: string[];
+    error?: SessionFsError;
 }
-/** @experimental */
-export interface SessionSkillsEnableParams {
-    /**
-     * Target session identifier
-     */
-    sessionId: string;
+export interface SessionFsReaddirWithTypesEntry {
     /**
-     * Name of the skill to enable
+     * Entry name
      */
     name: string;
+    type: SessionFsReaddirWithTypesEntryType;
 }
-/** @experimental */
-export interface SessionSkillsDisableResult {
-}
-/** @experimental */
-export interface SessionSkillsDisableParams {
+export interface SessionFsReaddirWithTypesRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
     /**
-     * Name of the skill to disable
+     * Path using SessionFs conventions
      */
-    name: string;
+    path: string;
 }
-/** @experimental */
-export interface SessionSkillsReloadResult {
+export interface SessionFsReaddirWithTypesResult {
+    /**
+     * Directory entries with type information
+     */
+    entries: SessionFsReaddirWithTypesEntry[];
+    error?: SessionFsError;
 }
-/** @experimental */
-export interface SessionSkillsReloadParams {
+export interface SessionFsReadFileRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
-}
-/** @experimental */
-export interface SessionMcpListResult {
     /**
-     * Configured MCP servers
+     * Path using SessionFs conventions
      */
-    servers: {
-        /**
-         * Server name (config key)
-         */
-        name: string;
-        /**
-         * Connection status: connected, failed, needs-auth, pending, disabled, or not_configured
-         */
-        status: "connected" | "failed" | "needs-auth" | "pending" | "disabled" | "not_configured";
-        /**
-         * Configuration source: user, workspace, plugin, or builtin
-         */
-        source?: string;
-        /**
-         * Error message if the server failed to connect
-         */
-        error?: string;
-    }[];
+    path: string;
 }
-/** @experimental */
-export interface SessionMcpListParams {
+export interface SessionFsReadFileResult {
     /**
-     * Target session identifier
+     * File content as UTF-8 string
      */
-    sessionId: string;
-}
-/** @experimental */
-export interface SessionMcpEnableResult {
+    content: string;
+    error?: SessionFsError;
 }
-/** @experimental */
-export interface SessionMcpEnableParams {
+export interface SessionFsRenameRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
     /**
-     * Name of the MCP server to enable
-     */
-    serverName: string;
-}
-/** @experimental */
-export interface SessionMcpDisableResult {
-}
-/** @experimental */
-export interface SessionMcpDisableParams {
-    /**
-     * Target session identifier
+     * Source path using SessionFs conventions
      */
-    sessionId: string;
+    src: string;
     /**
-     * Name of the MCP server to disable
+     * Destination path using SessionFs conventions
      */
-    serverName: string;
-}
-/** @experimental */
-export interface SessionMcpReloadResult {
+    dest: string;
 }
-/** @experimental */
-export interface SessionMcpReloadParams {
+export interface SessionFsRmRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
-}
-/** @experimental */
-export interface SessionPluginsListResult {
-    /**
-     * Installed plugins
-     */
-    plugins: {
-        /**
-         * Plugin name
-         */
-        name: string;
-        /**
-         * Marketplace the plugin came from
-         */
-        marketplace: string;
-        /**
-         * Installed version
-         */
-        version?: string;
-        /**
-         * Whether the plugin is currently enabled
-         */
-        enabled: boolean;
-    }[];
-}
-/** @experimental */
-export interface SessionPluginsListParams {
     /**
-     * Target session identifier
+     * Path using SessionFs conventions
      */
-    sessionId: string;
-}
-/** @experimental */
-export interface SessionExtensionsListResult {
+    path: string;
     /**
-     * Discovered extensions and their current status
+     * Remove directories and their contents recursively
      */
-    extensions: {
-        /**
-         * Source-qualified ID (e.g., 'project:my-ext', 'user:auth-helper')
-         */
-        id: string;
-        /**
-         * Extension name (directory name)
-         */
-        name: string;
-        /**
-         * Discovery source: project (.github/extensions/) or user (~/.copilot/extensions/)
-         */
-        source: "project" | "user";
-        /**
-         * Current status: running, disabled, failed, or starting
-         */
-        status: "running" | "disabled" | "failed" | "starting";
-        /**
-         * Process ID if the extension is running
-         */
-        pid?: number;
-    }[];
-}
-/** @experimental */
-export interface SessionExtensionsListParams {
+    recursive?: boolean;
     /**
-     * Target session identifier
+     * Ignore errors if the path does not exist
      */
-    sessionId: string;
-}
-/** @experimental */
-export interface SessionExtensionsEnableResult {
+    force?: boolean;
 }
-/** @experimental */
-export interface SessionExtensionsEnableParams {
+export interface SessionFsSetProviderRequest {
     /**
-     * Target session identifier
+     * Initial working directory for sessions
      */
-    sessionId: string;
+    initialCwd: string;
     /**
-     * Source-qualified extension ID to enable
+     * Path within each session's SessionFs where the runtime stores files for that session
      */
-    id: string;
-}
-/** @experimental */
-export interface SessionExtensionsDisableResult {
+    sessionStatePath: string;
+    conventions: SessionFsSetProviderConventions;
 }
-/** @experimental */
-export interface SessionExtensionsDisableParams {
-    /**
-     * Target session identifier
-     */
-    sessionId: string;
+export interface SessionFsSetProviderResult {
     /**
-     * Source-qualified extension ID to disable
+     * Whether the provider was set successfully
      */
-    id: string;
-}
-/** @experimental */
-export interface SessionExtensionsReloadResult {
+    success: boolean;
 }
-/** @experimental */
-export interface SessionExtensionsReloadParams {
+export interface SessionFsStatRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
-}
-/** @experimental */
-export interface SessionCompactionCompactResult {
     /**
-     * Whether compaction completed successfully
+     * Path using SessionFs conventions
      */
-    success: boolean;
+    path: string;
+}
+export interface SessionFsStatResult {
     /**
-     * Number of tokens freed by compaction
+     * Whether the path is a file
      */
-    tokensRemoved: number;
+    isFile: boolean;
     /**
-     * Number of messages removed during compaction
+     * Whether the path is a directory
      */
-    messagesRemoved: number;
-}
-/** @experimental */
-export interface SessionCompactionCompactParams {
+    isDirectory: boolean;
     /**
-     * Target session identifier
+     * File size in bytes
      */
-    sessionId: string;
-}
-export interface SessionToolsHandlePendingToolCallResult {
+    size: number;
     /**
-     * Whether the tool call result was handled successfully
+     * ISO 8601 timestamp of last modification
      */
-    success: boolean;
-}
-export interface SessionToolsHandlePendingToolCallParams {
+    mtime: string;
     /**
-     * Target session identifier
-     */
-    sessionId: string;
-    requestId: string;
-    result?: string | {
-        textResultForLlm: string;
-        resultType?: string;
-        error?: string;
-        toolTelemetry?: {
-            [k: string]: unknown;
-        };
-    };
-    error?: string;
-}
-export interface SessionCommandsHandlePendingCommandResult {
-    success: boolean;
+     * ISO 8601 timestamp of creation
+     */
+    birthtime: string;
+    error?: SessionFsError;
 }
-export interface SessionCommandsHandlePendingCommandParams {
+export interface SessionFsWriteFileRequest {
     /**
      * Target session identifier
      */
     sessionId: string;
     /**
-     * Request ID from the command invocation event
-     */
-    requestId: string;
-    /**
-     * Error message if the command handler failed
+     * Path using SessionFs conventions
      */
-    error?: string;
-}
-export interface SessionUiElicitationResult {
+    path: string;
     /**
-     * The user's response: accept (submitted), decline (rejected), or cancel (dismissed)
+     * Content to write
      */
-    action: "accept" | "decline" | "cancel";
+    content: string;
     /**
-     * The form values submitted by the user (present when action is 'accept')
+     * Optional POSIX-style mode for newly created files
      */
-    content?: {
-        [k: string]: string | number | boolean | string[];
-    };
+    mode?: number;
 }
-export interface SessionUiElicitationParams {
+/** @experimental */
+export interface SessionsForkRequest {
     /**
-     * Target session identifier
+     * Source session ID to fork from
      */
     sessionId: string;
     /**
-     * Message describing what information is needed from the user
+     * Optional event ID boundary. When provided, the fork includes only events before this ID (exclusive). When omitted, all events are included.
      */
-    message: string;
-    /**
-     * JSON Schema describing the form fields to present to the user
-     */
-    requestedSchema: {
-        /**
-         * Schema type indicator (always 'object')
-         */
-        type: "object";
-        /**
-         * Form field definitions, keyed by field name
-         */
-        properties: {
-            [k: string]: {
-                type: "string";
-                title?: string;
-                description?: string;
-                enum: string[];
-                enumNames?: string[];
-                default?: string;
-            } | {
-                type: "string";
-                title?: string;
-                description?: string;
-                oneOf: {
-                    const: string;
-                    title: string;
-                }[];
-                default?: string;
-            } | {
-                type: "array";
-                title?: string;
-                description?: string;
-                minItems?: number;
-                maxItems?: number;
-                items: {
-                    type: "string";
-                    enum: string[];
-                };
-                default?: string[];
-            } | {
-                type: "array";
-                title?: string;
-                description?: string;
-                minItems?: number;
-                maxItems?: number;
-                items: {
-                    anyOf: {
-                        const: string;
-                        title: string;
-                    }[];
-                };
-                default?: string[];
-            } | {
-                type: "boolean";
-                title?: string;
-                description?: string;
-                default?: boolean;
-            } | {
-                type: "string";
-                title?: string;
-                description?: string;
-                minLength?: number;
-                maxLength?: number;
-                format?: "email" | "uri" | "date" | "date-time";
-                default?: string;
-            } | {
-                type: "number" | "integer";
-                title?: string;
-                description?: string;
-                minimum?: number;
-                maximum?: number;
-                default?: number;
-            };
-        };
-        /**
-         * List of required field names
-         */
-        required?: string[];
-    };
+    toEventId?: string;
 }
-export interface SessionUiHandlePendingElicitationResult {
+/** @experimental */
+export interface SessionsForkResult {
     /**
-     * Whether the response was accepted. False if the request was already resolved by another client.
+     * The new forked session's ID
      */
-    success: boolean;
+    sessionId: string;
 }
-export interface SessionUiHandlePendingElicitationParams {
+export interface ShellExecRequest {
     /**
-     * Target session identifier
+     * Shell command to execute
      */
-    sessionId: string;
+    command: string;
     /**
-     * The unique request ID from the elicitation.requested event
+     * Working directory (defaults to session working directory)
      */
-    requestId: string;
+    cwd?: string;
     /**
-     * The elicitation response (accept with form values, decline, or cancel)
-     */
-    result: {
-        /**
-         * The user's response: accept (submitted), decline (rejected), or cancel (dismissed)
-         */
-        action: "accept" | "decline" | "cancel";
-        /**
-         * The form values submitted by the user (present when action is 'accept')
-         */
-        content?: {
-            [k: string]: string | number | boolean | string[];
-        };
-    };
+     * Timeout in milliseconds (default: 30000)
+     */
+    timeout?: number;
 }
-export interface SessionPermissionsHandlePendingPermissionRequestResult {
+export interface ShellExecResult {
     /**
-     * Whether the permission request was handled successfully
+     * Unique identifier for tracking streamed output
      */
-    success: boolean;
+    processId: string;
 }
-export interface SessionPermissionsHandlePendingPermissionRequestParams {
+export interface ShellKillRequest {
     /**
-     * Target session identifier
+     * Process identifier returned by shell.exec
      */
-    sessionId: string;
-    requestId: string;
-    result: {
-        kind: "approved";
-    } | {
-        kind: "denied-by-rules";
-        rules: unknown[];
-    } | {
-        kind: "denied-no-approval-rule-and-could-not-request-from-user";
-    } | {
-        kind: "denied-interactively-by-user";
-        feedback?: string;
-    } | {
-        kind: "denied-by-content-exclusion-policy";
-        path: string;
-        message: string;
-    } | {
-        kind: "denied-by-permission-request-hook";
-        message?: string;
-        interrupt?: boolean;
-    };
+    processId: string;
+    signal?: ShellKillSignal;
 }
-export interface SessionLogResult {
+export interface ShellKillResult {
     /**
-     * The unique identifier of the emitted session event
+     * Whether the signal was sent successfully
      */
-    eventId: string;
+    killed: boolean;
 }
-export interface SessionLogParams {
+export interface Skill {
     /**
-     * Target session identifier
+     * Unique identifier for the skill
      */
-    sessionId: string;
+    name: string;
     /**
-     * Human-readable message
+     * Description of what the skill does
      */
-    message: string;
+    description: string;
     /**
-     * Log severity level. Determines how the message is displayed in the timeline. Defaults to "info".
+     * Source location type (e.g., project, personal, plugin)
      */
-    level?: "info" | "warning" | "error";
+    source: string;
     /**
-     * When true, the message is transient and not persisted to the session event log on disk
+     * Whether the skill can be invoked by the user as a slash command
      */
-    ephemeral?: boolean;
+    userInvocable: boolean;
     /**
-     * Optional URL the user can open in their browser for more details
+     * Whether the skill is currently enabled
      */
-    url?: string;
-}
-export interface SessionShellExecResult {
+    enabled: boolean;
     /**
-     * Unique identifier for tracking streamed output
+     * Absolute path to the skill file
      */
-    processId: string;
+    path?: string;
 }
-export interface SessionShellExecParams {
+/** @experimental */
+export interface SkillList {
     /**
-     * Target session identifier
+     * Available skills
      */
-    sessionId: string;
+    skills: Skill[];
+}
+export interface SkillsConfigSetDisabledSkillsRequest {
     /**
-     * Shell command to execute
+     * List of skill names to disable
      */
-    command: string;
+    disabledSkills: string[];
+}
+/** @experimental */
+export interface SkillsDisableRequest {
     /**
-     * Working directory (defaults to session working directory)
+     * Name of the skill to disable
      */
-    cwd?: string;
+    name: string;
+}
+export interface SkillsDiscoverRequest {
     /**
-     * Timeout in milliseconds (default: 30000)
+     * Optional list of project directory paths to scan for project-scoped skills
      */
-    timeout?: number;
-}
-export interface SessionShellKillResult {
+    projectPaths?: string[];
     /**
-     * Whether the signal was sent successfully
+     * Optional list of additional skill directory paths to include
      */
-    killed: boolean;
+    skillDirectories?: string[];
 }
-export interface SessionShellKillParams {
+/** @experimental */
+export interface SkillsEnableRequest {
     /**
-     * Target session identifier
+     * Name of the skill to enable
      */
-    sessionId: string;
+    name: string;
+}
+export interface Tool {
     /**
-     * Process identifier returned by shell.exec
+     * Tool identifier (e.g., "bash", "grep", "str_replace_editor")
      */
-    processId: string;
+    name: string;
     /**
-     * Signal to send (default: SIGTERM)
+     * Optional namespaced name for declarative filtering (e.g., "playwright/navigate" for MCP tools)
      */
-    signal?: "SIGTERM" | "SIGKILL" | "SIGINT";
-}
-export interface SessionFsReadFileResult {
+    namespacedName?: string;
     /**
-     * File content as UTF-8 string
+     * Description of what the tool does
      */
-    content: string;
-}
-export interface SessionFsReadFileParams {
+    description: string;
     /**
-     * Target session identifier
+     * JSON Schema for the tool's input parameters
      */
-    sessionId: string;
+    parameters?: {
+        [k: string]: unknown;
+    };
     /**
-     * Path using SessionFs conventions
+     * Optional instructions for how to use this tool effectively
      */
-    path: string;
+    instructions?: string;
 }
-export interface SessionFsWriteFileParams {
+export interface ToolCallResult {
     /**
-     * Target session identifier
+     * Text result to send back to the LLM
      */
-    sessionId: string;
+    textResultForLlm: string;
     /**
-     * Path using SessionFs conventions
+     * Type of the tool result
      */
-    path: string;
+    resultType?: string;
     /**
-     * Content to write
+     * Error message if the tool call failed
      */
-    content: string;
+    error?: string;
     /**
-     * Optional POSIX-style mode for newly created files
+     * Telemetry data from tool execution
      */
-    mode?: number;
+    toolTelemetry?: {
+        [k: string]: unknown;
+    };
 }
-export interface SessionFsAppendFileParams {
+export interface ToolList {
     /**
-     * Target session identifier
+     * List of available built-in tools with metadata
      */
-    sessionId: string;
+    tools: Tool[];
+}
+export interface ToolsHandlePendingToolCallRequest {
     /**
-     * Path using SessionFs conventions
+     * Request ID of the pending tool call
      */
-    path: string;
+    requestId: string;
+    result?: ToolsHandlePendingToolCall;
     /**
-     * Content to append
+     * Error message if the tool call failed
      */
-    content: string;
+    error?: string;
+}
+export interface ToolsListRequest {
     /**
-     * Optional POSIX-style mode for newly created files
+     * Optional model ID — when provided, the returned tool list reflects model-specific overrides
      */
-    mode?: number;
+    model?: string;
 }
-export interface SessionFsExistsResult {
+export interface UIElicitationArrayAnyOfField {
+    type: "array";
+    title?: string;
+    description?: string;
+    minItems?: number;
+    maxItems?: number;
+    items: UIElicitationArrayAnyOfFieldItems;
+    default?: string[];
+}
+export interface UIElicitationArrayAnyOfFieldItems {
+    anyOf: UIElicitationArrayAnyOfFieldItemsAnyOf[];
+}
+export interface UIElicitationArrayAnyOfFieldItemsAnyOf {
+    const: string;
+    title: string;
+}
+export interface UIElicitationArrayEnumField {
+    type: "array";
+    title?: string;
+    description?: string;
+    minItems?: number;
+    maxItems?: number;
+    items: UIElicitationArrayEnumFieldItems;
+    default?: string[];
+}
+export interface UIElicitationArrayEnumFieldItems {
+    type: "string";
+    enum: string[];
+}
+export interface UIElicitationRequest {
     /**
-     * Whether the path exists
+     * Message describing what information is needed from the user
      */
-    exists: boolean;
+    message: string;
+    requestedSchema: UIElicitationSchema;
 }
-export interface SessionFsExistsParams {
+/**
+ * JSON Schema describing the form fields to present to the user
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UIElicitationSchema".
+ */
+export interface UIElicitationSchema {
     /**
-     * Target session identifier
+     * Schema type indicator (always 'object')
      */
-    sessionId: string;
+    type: "object";
     /**
-     * Path using SessionFs conventions
+     * Form field definitions, keyed by field name
      */
-    path: string;
+    properties: {
+        [k: string]: UIElicitationSchemaProperty;
+    };
+    /**
+     * List of required field names
+     */
+    required?: string[];
+}
+export interface UIElicitationStringEnumField {
+    type: "string";
+    title?: string;
+    description?: string;
+    enum: string[];
+    enumNames?: string[];
+    default?: string;
+}
+export interface UIElicitationStringOneOfField {
+    type: "string";
+    title?: string;
+    description?: string;
+    oneOf: UIElicitationStringOneOfFieldOneOf[];
+    default?: string;
+}
+export interface UIElicitationStringOneOfFieldOneOf {
+    const: string;
+    title: string;
+}
+export interface UIElicitationSchemaPropertyBoolean {
+    type: "boolean";
+    title?: string;
+    description?: string;
+    default?: boolean;
+}
+export interface UIElicitationSchemaPropertyString {
+    type: "string";
+    title?: string;
+    description?: string;
+    minLength?: number;
+    maxLength?: number;
+    format?: UIElicitationSchemaPropertyStringFormat;
+    default?: string;
+}
+export interface UIElicitationSchemaPropertyNumber {
+    type: UIElicitationSchemaPropertyNumberType;
+    title?: string;
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    default?: number;
 }
-export interface SessionFsStatResult {
+/**
+ * The elicitation response (accept with form values, decline, or cancel)
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UIElicitationResponse".
+ */
+export interface UIElicitationResponse {
+    action: UIElicitationResponseAction;
+    content?: UIElicitationResponseContent;
+}
+/**
+ * The form values submitted by the user (present when action is 'accept')
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UIElicitationResponseContent".
+ */
+export interface UIElicitationResponseContent {
+    [k: string]: UIElicitationFieldValue;
+}
+export interface UIElicitationResult {
     /**
-     * Whether the path is a file
+     * Whether the response was accepted. False if the request was already resolved by another client.
      */
-    isFile: boolean;
+    success: boolean;
+}
+export interface UIHandlePendingElicitationRequest {
     /**
-     * Whether the path is a directory
+     * The unique request ID from the elicitation.requested event
      */
-    isDirectory: boolean;
+    requestId: string;
+    result: UIElicitationResponse;
+}
+/** @experimental */
+export interface UsageGetMetricsResult {
     /**
-     * File size in bytes
+     * Total user-initiated premium request cost across all models (may be fractional due to multipliers)
      */
-    size: number;
+    totalPremiumRequestCost: number;
     /**
-     * ISO 8601 timestamp of last modification
+     * Raw count of user-initiated API requests
      */
-    mtime: string;
+    totalUserRequests: number;
     /**
-     * ISO 8601 timestamp of creation
+     * Total time spent in model API calls (milliseconds)
      */
-    birthtime: string;
-}
-export interface SessionFsStatParams {
+    totalApiDurationMs: number;
     /**
-     * Target session identifier
+     * Session start timestamp (epoch milliseconds)
      */
-    sessionId: string;
+    sessionStartTime: number;
+    codeChanges: UsageMetricsCodeChanges;
     /**
-     * Path using SessionFs conventions
+     * Per-model token and request metrics, keyed by model identifier
      */
-    path: string;
-}
-export interface SessionFsMkdirParams {
+    modelMetrics: {
+        [k: string]: UsageMetricsModelMetric;
+    };
     /**
-     * Target session identifier
+     * Currently active model identifier
      */
-    sessionId: string;
+    currentModel?: string;
     /**
-     * Path using SessionFs conventions
+     * Input tokens from the most recent main-agent API call
      */
-    path: string;
+    lastCallInputTokens: number;
     /**
-     * Create parent directories as needed
+     * Output tokens from the most recent main-agent API call
      */
-    recursive?: boolean;
+    lastCallOutputTokens: number;
+}
+/**
+ * Aggregated code change metrics
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UsageMetricsCodeChanges".
+ */
+export interface UsageMetricsCodeChanges {
     /**
-     * Optional POSIX-style mode for newly created directories
+     * Total lines of code added
      */
-    mode?: number;
-}
-export interface SessionFsReaddirResult {
+    linesAdded: number;
     /**
-     * Entry names in the directory
+     * Total lines of code removed
      */
-    entries: string[];
+    linesRemoved: number;
+    /**
+     * Number of distinct files modified
+     */
+    filesModifiedCount: number;
 }
-export interface SessionFsReaddirParams {
+export interface UsageMetricsModelMetric {
+    requests: UsageMetricsModelMetricRequests;
+    usage: UsageMetricsModelMetricUsage;
+}
+/**
+ * Request count and cost metrics for this model
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UsageMetricsModelMetricRequests".
+ */
+export interface UsageMetricsModelMetricRequests {
     /**
-     * Target session identifier
+     * Number of API requests made with this model
      */
-    sessionId: string;
+    count: number;
     /**
-     * Path using SessionFs conventions
+     * User-initiated premium request cost (with multiplier applied)
      */
-    path: string;
+    cost: number;
 }
-export interface SessionFsReaddirWithTypesResult {
+/**
+ * Token usage metrics for this model
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "UsageMetricsModelMetricUsage".
+ */
+export interface UsageMetricsModelMetricUsage {
     /**
-     * Directory entries with type information
+     * Total input tokens consumed
      */
-    entries: {
-        /**
-         * Entry name
-         */
-        name: string;
-        /**
-         * Entry type
-         */
-        type: "file" | "directory";
-    }[];
-}
-export interface SessionFsReaddirWithTypesParams {
+    inputTokens: number;
     /**
-     * Target session identifier
+     * Total output tokens produced
      */
-    sessionId: string;
+    outputTokens: number;
     /**
-     * Path using SessionFs conventions
+     * Total tokens read from prompt cache
      */
-    path: string;
-}
-export interface SessionFsRmParams {
+    cacheReadTokens: number;
     /**
-     * Target session identifier
+     * Total tokens written to prompt cache
      */
-    sessionId: string;
+    cacheWriteTokens: number;
     /**
-     * Path using SessionFs conventions
+     * Total output tokens used for reasoning
+     */
+    reasoningTokens?: number;
+}
+export interface WorkspacesCreateFileRequest {
+    /**
+     * Relative path within the workspace files directory
      */
     path: string;
     /**
-     * Remove directories and their contents recursively
+     * File content to write as a UTF-8 string
      */
-    recursive?: boolean;
+    content: string;
+}
+export interface WorkspacesGetWorkspaceResult {
     /**
-     * Ignore errors if the path does not exist
+     * Current workspace metadata, or null if not available
      */
-    force?: boolean;
+    workspace: {
+        id: string;
+        cwd?: string;
+        git_root?: string;
+        repository?: string;
+        host_type?: "github" | "ado";
+        branch?: string;
+        summary?: string;
+        name?: string;
+        summary_count?: number;
+        created_at?: string;
+        updated_at?: string;
+        remote_steerable?: boolean;
+        mc_task_id?: string;
+        mc_session_id?: string;
+        mc_last_event_id?: string;
+        session_sync_level?: "local" | "user" | "repo_and_user";
+        chronicle_sync_dismissed?: boolean;
+    } | null;
 }
-export interface SessionFsRenameParams {
+export interface WorkspacesListFilesResult {
     /**
-     * Target session identifier
+     * Relative file paths in the workspace files directory
      */
-    sessionId: string;
+    files: string[];
+}
+export interface WorkspacesReadFileRequest {
     /**
-     * Source path using SessionFs conventions
+     * Relative path within the workspace files directory
      */
-    src: string;
+    path: string;
+}
+export interface WorkspacesReadFileResult {
     /**
-     * Destination path using SessionFs conventions
+     * File content as a UTF-8 string
      */
-    dest: string;
+    content: string;
 }
 /** Create typed server-scoped RPC methods (no session required). */
 export declare function createServerRpc(connection: MessageConnection): {
-    ping: (params: PingParams) => Promise<PingResult>;
+    ping: (params: PingRequest) => Promise<PingResult>;
     models: {
-        list: () => Promise<ModelsListResult>;
+        list: () => Promise<ModelList>;
     };
     tools: {
-        list: (params: ToolsListParams) => Promise<ToolsListResult>;
+        list: (params: ToolsListRequest) => Promise<ToolList>;
     };
     account: {
         getQuota: () => Promise<AccountGetQuotaResult>;
     };
     mcp: {
         config: {
-            list: () => Promise<McpConfigListResult>;
-            add: (params: McpConfigAddParams) => Promise<void>;
-            update: (params: McpConfigUpdateParams) => Promise<void>;
-            remove: (params: McpConfigRemoveParams) => Promise<void>;
+            list: () => Promise<McpConfigList>;
+            add: (params: McpConfigAddRequest) => Promise<void>;
+            update: (params: McpConfigUpdateRequest) => Promise<void>;
+            remove: (params: McpConfigRemoveRequest) => Promise<void>;
+        };
+        discover: (params: McpDiscoverRequest) => Promise<McpDiscoverResult>;
+    };
+    skills: {
+        config: {
+            setDisabledSkills: (params: SkillsConfigSetDisabledSkillsRequest) => Promise<void>;
         };
+        discover: (params: SkillsDiscoverRequest) => Promise<ServerSkillList>;
     };
     sessionFs: {
-        setProvider: (params: SessionFsSetProviderParams) => Promise<SessionFsSetProviderResult>;
+        setProvider: (params: SessionFsSetProviderRequest) => Promise<SessionFsSetProviderResult>;
+    };
+    /** @experimental */
+    sessions: {
+        fork: (params: SessionsForkRequest) => Promise<SessionsForkResult>;
     };
 };
 /** Create typed session-scoped RPC methods. */
 export declare function createSessionRpc(connection: MessageConnection, sessionId: string): {
     model: {
-        getCurrent: () => Promise<SessionModelGetCurrentResult>;
-        switchTo: (params: Omit<SessionModelSwitchToParams, "sessionId">) => Promise<SessionModelSwitchToResult>;
+        getCurrent: () => Promise<CurrentModel>;
+        switchTo: (params: Omit<ModelSwitchToRequest, "sessionId">) => Promise<ModelSwitchToResult>;
     };
     mode: {
-        get: () => Promise<SessionModeGetResult>;
-        set: (params: Omit<SessionModeSetParams, "sessionId">) => Promise<SessionModeSetResult>;
+        get: () => Promise<SessionMode>;
+        set: (params: Omit<ModeSetRequest, "sessionId">) => Promise<void>;
+    };
+    name: {
+        get: () => Promise<NameGetResult>;
+        set: (params: Omit<NameSetRequest, "sessionId">) => Promise<void>;
     };
     plan: {
-        read: () => Promise<SessionPlanReadResult>;
-        update: (params: Omit<SessionPlanUpdateParams, "sessionId">) => Promise<SessionPlanUpdateResult>;
-        delete: () => Promise<SessionPlanDeleteResult>;
+        read: () => Promise<PlanReadResult>;
+        update: (params: Omit<PlanUpdateRequest, "sessionId">) => Promise<void>;
+        delete: () => Promise<void>;
     };
-    workspace: {
-        listFiles: () => Promise<SessionWorkspaceListFilesResult>;
-        readFile: (params: Omit<SessionWorkspaceReadFileParams, "sessionId">) => Promise<SessionWorkspaceReadFileResult>;
-        createFile: (params: Omit<SessionWorkspaceCreateFileParams, "sessionId">) => Promise<SessionWorkspaceCreateFileResult>;
+    workspaces: {
+        getWorkspace: () => Promise<WorkspacesGetWorkspaceResult>;
+        listFiles: () => Promise<WorkspacesListFilesResult>;
+        readFile: (params: Omit<WorkspacesReadFileRequest, "sessionId">) => Promise<WorkspacesReadFileResult>;
+        createFile: (params: Omit<WorkspacesCreateFileRequest, "sessionId">) => Promise<void>;
+    };
+    instructions: {
+        getSources: () => Promise<InstructionsGetSourcesResult>;
     };
     /** @experimental */
     fleet: {
-        start: (params: Omit<SessionFleetStartParams, "sessionId">) => Promise<SessionFleetStartResult>;
+        start: (params: Omit<FleetStartRequest, "sessionId">) => Promise<FleetStartResult>;
     };
     /** @experimental */
     agent: {
-        list: () => Promise<SessionAgentListResult>;
-        getCurrent: () => Promise<SessionAgentGetCurrentResult>;
-        select: (params: Omit<SessionAgentSelectParams, "sessionId">) => Promise<SessionAgentSelectResult>;
-        deselect: () => Promise<SessionAgentDeselectResult>;
-        reload: () => Promise<SessionAgentReloadResult>;
+        list: () => Promise<AgentList>;
+        getCurrent: () => Promise<AgentGetCurrentResult>;
+        select: (params: Omit<AgentSelectRequest, "sessionId">) => Promise<AgentSelectResult>;
+        deselect: () => Promise<void>;
+        reload: () => Promise<AgentReloadResult>;
     };
     /** @experimental */
     skills: {
-        list: () => Promise<SessionSkillsListResult>;
-        enable: (params: Omit<SessionSkillsEnableParams, "sessionId">) => Promise<SessionSkillsEnableResult>;
-        disable: (params: Omit<SessionSkillsDisableParams, "sessionId">) => Promise<SessionSkillsDisableResult>;
-        reload: () => Promise<SessionSkillsReloadResult>;
+        list: () => Promise<SkillList>;
+        enable: (params: Omit<SkillsEnableRequest, "sessionId">) => Promise<void>;
+        disable: (params: Omit<SkillsDisableRequest, "sessionId">) => Promise<void>;
+        reload: () => Promise<void>;
     };
     /** @experimental */
     mcp: {
-        list: () => Promise<SessionMcpListResult>;
-        enable: (params: Omit<SessionMcpEnableParams, "sessionId">) => Promise<SessionMcpEnableResult>;
-        disable: (params: Omit<SessionMcpDisableParams, "sessionId">) => Promise<SessionMcpDisableResult>;
-        reload: () => Promise<SessionMcpReloadResult>;
+        list: () => Promise<McpServerList>;
+        enable: (params: Omit<McpEnableRequest, "sessionId">) => Promise<void>;
+        disable: (params: Omit<McpDisableRequest, "sessionId">) => Promise<void>;
+        reload: () => Promise<void>;
     };
     /** @experimental */
     plugins: {
-        list: () => Promise<SessionPluginsListResult>;
+        list: () => Promise<PluginList>;
     };
     /** @experimental */
     extensions: {
-        list: () => Promise<SessionExtensionsListResult>;
-        enable: (params: Omit<SessionExtensionsEnableParams, "sessionId">) => Promise<SessionExtensionsEnableResult>;
-        disable: (params: Omit<SessionExtensionsDisableParams, "sessionId">) => Promise<SessionExtensionsDisableResult>;
-        reload: () => Promise<SessionExtensionsReloadResult>;
-    };
-    /** @experimental */
-    compaction: {
-        compact: () => Promise<SessionCompactionCompactResult>;
+        list: () => Promise<ExtensionList>;
+        enable: (params: Omit<ExtensionsEnableRequest, "sessionId">) => Promise<void>;
+        disable: (params: Omit<ExtensionsDisableRequest, "sessionId">) => Promise<void>;
+        reload: () => Promise<void>;
     };
     tools: {
-        handlePendingToolCall: (params: Omit<SessionToolsHandlePendingToolCallParams, "sessionId">) => Promise<SessionToolsHandlePendingToolCallResult>;
+        handlePendingToolCall: (params: Omit<ToolsHandlePendingToolCallRequest, "sessionId">) => Promise<HandleToolCallResult>;
     };
     commands: {
-        handlePendingCommand: (params: Omit<SessionCommandsHandlePendingCommandParams, "sessionId">) => Promise<SessionCommandsHandlePendingCommandResult>;
+        handlePendingCommand: (params: Omit<CommandsHandlePendingCommandRequest, "sessionId">) => Promise<CommandsHandlePendingCommandResult>;
     };
     ui: {
-        elicitation: (params: Omit<SessionUiElicitationParams, "sessionId">) => Promise<SessionUiElicitationResult>;
-        handlePendingElicitation: (params: Omit<SessionUiHandlePendingElicitationParams, "sessionId">) => Promise<SessionUiHandlePendingElicitationResult>;
+        elicitation: (params: Omit<UIElicitationRequest, "sessionId">) => Promise<UIElicitationResponse>;
+        handlePendingElicitation: (params: Omit<UIHandlePendingElicitationRequest, "sessionId">) => Promise<UIElicitationResult>;
     };
     permissions: {
-        handlePendingPermissionRequest: (params: Omit<SessionPermissionsHandlePendingPermissionRequestParams, "sessionId">) => Promise<SessionPermissionsHandlePendingPermissionRequestResult>;
+        handlePendingPermissionRequest: (params: Omit<PermissionDecisionRequest, "sessionId">) => Promise<PermissionRequestResult>;
     };
-    log: (params: Omit<SessionLogParams, "sessionId">) => Promise<SessionLogResult>;
+    log: (params: Omit<LogRequest, "sessionId">) => Promise<LogResult>;
     shell: {
-        exec: (params: Omit<SessionShellExecParams, "sessionId">) => Promise<SessionShellExecResult>;
-        kill: (params: Omit<SessionShellKillParams, "sessionId">) => Promise<SessionShellKillResult>;
+        exec: (params: Omit<ShellExecRequest, "sessionId">) => Promise<ShellExecResult>;
+        kill: (params: Omit<ShellKillRequest, "sessionId">) => Promise<ShellKillResult>;
+    };
+    /** @experimental */
+    history: {
+        compact: () => Promise<HistoryCompactResult>;
+        truncate: (params: Omit<HistoryTruncateRequest, "sessionId">) => Promise<HistoryTruncateResult>;
+    };
+    /** @experimental */
+    usage: {
+        getMetrics: () => Promise<UsageGetMetricsResult>;
     };
 };
 /** Handler for `sessionFs` client session API methods. */
 export interface SessionFsHandler {
-    readFile(params: SessionFsReadFileParams): Promise<SessionFsReadFileResult>;
-    writeFile(params: SessionFsWriteFileParams): Promise<void>;
-    appendFile(params: SessionFsAppendFileParams): Promise<void>;
-    exists(params: SessionFsExistsParams): Promise<SessionFsExistsResult>;
-    stat(params: SessionFsStatParams): Promise<SessionFsStatResult>;
-    mkdir(params: SessionFsMkdirParams): Promise<void>;
-    readdir(params: SessionFsReaddirParams): Promise<SessionFsReaddirResult>;
-    readdirWithTypes(params: SessionFsReaddirWithTypesParams): Promise<SessionFsReaddirWithTypesResult>;
-    rm(params: SessionFsRmParams): Promise<void>;
-    rename(params: SessionFsRenameParams): Promise<void>;
+    readFile(params: SessionFsReadFileRequest): Promise<SessionFsReadFileResult>;
+    writeFile(params: SessionFsWriteFileRequest): Promise<SessionFsError | undefined>;
+    appendFile(params: SessionFsAppendFileRequest): Promise<SessionFsError | undefined>;
+    exists(params: SessionFsExistsRequest): Promise<SessionFsExistsResult>;
+    stat(params: SessionFsStatRequest): Promise<SessionFsStatResult>;
+    mkdir(params: SessionFsMkdirRequest): Promise<SessionFsError | undefined>;
+    readdir(params: SessionFsReaddirRequest): Promise<SessionFsReaddirResult>;
+    readdirWithTypes(params: SessionFsReaddirWithTypesRequest): Promise<SessionFsReaddirWithTypesResult>;
+    rm(params: SessionFsRmRequest): Promise<SessionFsError | undefined>;
+    rename(params: SessionFsRenameRequest): Promise<SessionFsError | undefined>;
 }
 /** All client session API handler groups. */
 export interface ClientSessionApiHandlers {