@github/copilot-sdk 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/generated/rpc.js

@@ -1,160 +1,1277 @@
 function createServerRpc(connection) {
   return {
+    /**
+     * Checks server responsiveness and returns protocol information.
+     *
+     * @param params Optional message to echo back to the caller.
+     *
+     * @returns Server liveness response, including the echoed message, current server timestamp, and protocol version.
+     */
     ping: async (params) => connection.sendRequest("ping", params),
     models: {
+      /**
+       * Lists Copilot models available to the authenticated user.
+       *
+       * @param params Optional GitHub token used to list models for a specific user instead of the global auth context.
+       *
+       * @returns List of Copilot models available to the resolved user, including capabilities and billing metadata.
+       */
       list: async (params) => connection.sendRequest("models.list", params)
     },
     tools: {
+      /**
+       * Lists built-in tools available for a model.
+       *
+       * @param 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.
+       */
       list: async (params) => connection.sendRequest("tools.list", params)
     },
     account: {
+      /**
+       * Gets Copilot quota usage for the authenticated user or supplied GitHub token.
+       *
+       * @param params Optional GitHub token used to look up quota for a specific user instead of the global auth context.
+       *
+       * @returns Quota usage snapshots for the resolved user, keyed by quota type.
+       */
       getQuota: async (params) => connection.sendRequest("account.getQuota", params)
     },
     mcp: {
       config: {
+        /**
+         * Lists MCP servers from user configuration.
+         *
+         * @returns User-configured MCP servers, keyed by server name.
+         */
         list: async () => connection.sendRequest("mcp.config.list", {}),
+        /**
+         * Adds an MCP server to user configuration.
+         *
+         * @param params MCP server name and configuration to add to user configuration.
+         */
         add: async (params) => connection.sendRequest("mcp.config.add", params),
+        /**
+         * Updates an MCP server in user configuration.
+         *
+         * @param params MCP server name and replacement configuration to write to user configuration.
+         */
         update: async (params) => connection.sendRequest("mcp.config.update", params),
+        /**
+         * Removes an MCP server from user configuration.
+         *
+         * @param params MCP server name to remove from user configuration.
+         */
         remove: async (params) => connection.sendRequest("mcp.config.remove", params),
+        /**
+         * Enables MCP servers in user configuration for new sessions.
+         *
+         * @param params MCP server names to enable for new sessions.
+         */
         enable: async (params) => connection.sendRequest("mcp.config.enable", params),
+        /**
+         * Disables MCP servers in user configuration for new sessions.
+         *
+         * @param params MCP server names to disable for new sessions.
+         */
         disable: async (params) => connection.sendRequest("mcp.config.disable", params)
       },
+      /**
+       * Discovers MCP servers from user, workspace, plugin, and builtin sources.
+       *
+       * @param params Optional working directory used as context for MCP server discovery.
+       *
+       * @returns MCP servers discovered from user, workspace, plugin, and built-in sources.
+       */
       discover: async (params) => connection.sendRequest("mcp.discover", params)
     },
     skills: {
       config: {
+        /**
+         * Replaces the global list of disabled skills.
+         *
+         * @param params Skill names to mark as disabled in global configuration, replacing any previous list.
+         */
         setDisabledSkills: async (params) => connection.sendRequest("skills.config.setDisabledSkills", params)
       },
+      /**
+       * Discovers skills across global and project sources.
+       *
+       * @param params Optional project paths and additional skill directories to include in discovery.
+       *
+       * @returns Skills discovered across global and project sources.
+       */
       discover: async (params) => connection.sendRequest("skills.discover", params)
     },
     sessionFs: {
+      /**
+       * Registers an SDK client as the session filesystem provider.
+       *
+       * @param 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.
+       */
       setProvider: async (params) => connection.sendRequest("sessionFs.setProvider", params)
     },
     /** @experimental */
     sessions: {
-      fork: async (params) => connection.sendRequest("sessions.fork", params)
+      /**
+       * Creates a new session by forking persisted history from an existing session.
+       *
+       * @param 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.
+       */
+      fork: async (params) => connection.sendRequest("sessions.fork", params),
+      /**
+       * Connects to an existing remote session and exposes it as an SDK session.
+       *
+       * @param params Remote session connection parameters.
+       *
+       * @returns Remote session connection result.
+       */
+      connect: async (params) => connection.sendRequest("sessions.connect", params),
+      /**
+       * Lists persisted sessions, optionally filtered by working-directory context.
+       *
+       * @param params Optional metadata-load limit and context filter applied to the returned sessions.
+       *
+       * @returns Persisted sessions matching the filter, ordered most-recently-modified first.
+       */
+      list: async (params) => connection.sendRequest("sessions.list", params),
+      /**
+       * Finds the local session bound to a GitHub task ID, if any.
+       *
+       * @param params GitHub task ID to look up.
+       *
+       * @returns ID of the local session bound to the given GitHub task, or omitted when none.
+       */
+      findByTaskId: async (params) => connection.sendRequest("sessions.findByTaskId", params),
+      /**
+       * Resolves a UUID prefix to a unique session ID, if exactly one session matches.
+       *
+       * @param params UUID prefix to resolve to a unique session ID.
+       *
+       * @returns Session ID matching the prefix, omitted when no unique match exists.
+       */
+      findByPrefix: async (params) => connection.sendRequest("sessions.findByPrefix", params),
+      /**
+       * Returns the most-relevant prior session for a given working-directory context.
+       *
+       * @param 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.
+       */
+      getLastForContext: async (params) => connection.sendRequest("sessions.getLastForContext", params),
+      /**
+       * Computes the absolute path to a session's persisted events.jsonl file.
+       *
+       * @param params Session ID whose event-log file path to compute.
+       *
+       * @returns Absolute path to the session's events.jsonl file on disk.
+       */
+      getEventFilePath: async (params) => connection.sendRequest("sessions.getEventFilePath", params),
+      /**
+       * Returns the on-disk byte size of each session's workspace directory.
+       *
+       * @returns Map of sessionId -> on-disk size in bytes for each session's workspace directory.
+       */
+      getSizes: async () => connection.sendRequest("sessions.getSizes", {}),
+      /**
+       * Returns the subset of the supplied session IDs that are currently held by another running process.
+       *
+       * @param 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.
+       */
+      checkInUse: async (params) => connection.sendRequest("sessions.checkInUse", params),
+      /**
+       * Returns a session's persisted remote-steerable flag, if any has been recorded.
+       *
+       * @param 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.
+       */
+      getPersistedRemoteSteerable: async (params) => connection.sendRequest("sessions.getPersistedRemoteSteerable", params),
+      /**
+       * Closes a session: emits shutdown, flushes pending events, releases the in-use lock, and disposes the active session.
+       *
+       * @param 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.
+       */
+      close: async (params) => connection.sendRequest("sessions.close", params),
+      /**
+       * Closes, deactivates, and deletes a set of sessions, returning the bytes freed per session.
+       *
+       * @param params Session IDs to close, deactivate, and delete from disk.
+       *
+       * @returns Map of sessionId -> bytes freed by removing the session's workspace directory.
+       */
+      bulkDelete: async (params) => connection.sendRequest("sessions.bulkDelete", params),
+      /**
+       * Deletes sessions older than the given threshold, with optional dry-run and exclusion list.
+       *
+       * @param 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.
+       */
+      pruneOld: async (params) => connection.sendRequest("sessions.pruneOld", params),
+      /**
+       * Flushes a session's pending events to disk.
+       *
+       * @param 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).
+       */
+      save: async (params) => connection.sendRequest("sessions.save", params),
+      /**
+       * Releases the in-use lock held by this process for a session.
+       *
+       * @param 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.
+       */
+      releaseLock: async (params) => connection.sendRequest("sessions.releaseLock", params),
+      /**
+       * Backfills missing summary and context fields on the supplied session metadata records.
+       *
+       * @param params Session metadata records to enrich with summary and context information.
+       *
+       * @returns The same metadata records, with summary and context fields backfilled where available.
+       */
+      enrichMetadata: async (params) => connection.sendRequest("sessions.enrichMetadata", params),
+      /**
+       * Reloads user, plugin, and (optionally) repo hooks on the active session.
+       *
+       * @param 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.
+       */
+      reloadPluginHooks: async (params) => connection.sendRequest("sessions.reloadPluginHooks", params),
+      /**
+       * Loads previously-deferred repo-level hooks on the active session, returning queued startup prompts.
+       *
+       * @param 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.
+       */
+      loadDeferredRepoHooks: async (params) => connection.sendRequest("sessions.loadDeferredRepoHooks", params),
+      /**
+       * Replaces the manager-wide additional plugins registered with the session manager.
+       *
+       * @param 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.
+       */
+      setAdditionalPlugins: async (params) => connection.sendRequest("sessions.setAdditionalPlugins", params)
     }
   };
 }
 function createInternalServerRpc(connection) {
   return {
+    /**
+     * Performs the SDK server connection handshake and validates the optional connection token.
+     *
+     * @param params Optional connection token presented by the SDK client during the handshake.
+     *
+     * @returns Handshake result reporting the server's protocol version and package version on success.
+     */
     connect: async (params) => connection.sendRequest("connect", params)
   };
 }
 function createSessionRpc(connection, sessionId) {
   return {
+    /**
+     * Suspends the session while preserving persisted state for later resume.
+     *
+     * @experimental
+     */
     suspend: async () => connection.sendRequest("session.suspend", { sessionId }),
+    /**
+     * Sends a user message to the session and returns its message ID.
+     *
+     * @param params Parameters for sending a user message to the session
+     *
+     * @returns Result of sending a user message
+     *
+     * @experimental
+     */
+    send: async (params) => connection.sendRequest("session.send", { sessionId, ...params }),
+    /**
+     * Aborts the current agent turn.
+     *
+     * @param params Parameters for aborting the current turn
+     *
+     * @returns Result of aborting the current turn
+     *
+     * @experimental
+     */
+    abort: async (params) => connection.sendRequest("session.abort", { sessionId, ...params }),
+    /**
+     * 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.
+     *
+     * @param params Parameters for shutting down the session
+     *
+     * @experimental
+     */
+    shutdown: async (params) => connection.sendRequest("session.shutdown", { sessionId, ...params }),
+    /** @experimental */
     auth: {
-      getStatus: async () => connection.sendRequest("session.auth.getStatus", { sessionId })
+      /**
+       * Gets authentication status and account metadata for the session.
+       *
+       * @returns Authentication status and account metadata for the session.
+       */
+      getStatus: async () => connection.sendRequest("session.auth.getStatus", { sessionId }),
+      /**
+       * Updates the session's auth credentials used for outbound model and API requests.
+       *
+       * @param params New auth credentials to install on the session. Omit to leave credentials unchanged.
+       *
+       * @returns Indicates whether the credential update succeeded.
+       */
+      setCredentials: async (params) => connection.sendRequest("session.auth.setCredentials", { sessionId, ...params })
     },
+    /** @experimental */
     model: {
+      /**
+       * Gets the currently selected model for the session.
+       *
+       * @returns The currently selected model and reasoning effort for the session.
+       */
       getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
-      switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params })
+      /**
+       * Switches the session to a model and optional reasoning configuration.
+       *
+       * @param params Target model identifier and optional reasoning effort, summary, and capability overrides.
+       *
+       * @returns The model identifier active on the session after the switch.
+       */
+      switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params }),
+      /**
+       * Updates the session's reasoning effort without changing the selected model.
+       *
+       * @param 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.
+       */
+      setReasoningEffort: async (params) => connection.sendRequest("session.model.setReasoningEffort", { sessionId, ...params })
     },
+    /** @experimental */
     mode: {
+      /**
+       * Gets the current agent interaction mode.
+       *
+       * @returns The session mode the agent is operating in
+       */
       get: async () => connection.sendRequest("session.mode.get", { sessionId }),
+      /**
+       * Sets the current agent interaction mode.
+       *
+       * @param params Agent interaction mode to apply to the session.
+       */
       set: async (params) => connection.sendRequest("session.mode.set", { sessionId, ...params })
     },
+    /** @experimental */
     name: {
+      /**
+       * Gets the session's friendly name.
+       *
+       * @returns The session's friendly name, or null when not yet set.
+       */
       get: async () => connection.sendRequest("session.name.get", { sessionId }),
-      set: async (params) => connection.sendRequest("session.name.set", { sessionId, ...params })
+      /**
+       * Sets the session's friendly name.
+       *
+       * @param params New friendly name to apply to the session.
+       */
+      set: async (params) => connection.sendRequest("session.name.set", { sessionId, ...params }),
+      /**
+       * Persists an auto-generated session summary as the session's name when no user-set name exists.
+       *
+       * @param 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.
+       */
+      setAuto: async (params) => connection.sendRequest("session.name.setAuto", { sessionId, ...params })
     },
+    /** @experimental */
     plan: {
+      /**
+       * Reads the session plan file from the workspace.
+       *
+       * @returns Existence, contents, and resolved path of the session plan file.
+       */
       read: async () => connection.sendRequest("session.plan.read", { sessionId }),
+      /**
+       * Writes new content to the session plan file.
+       *
+       * @param params Replacement contents to write to the session plan file.
+       */
       update: async (params) => connection.sendRequest("session.plan.update", { sessionId, ...params }),
+      /**
+       * Deletes the session plan file from the workspace.
+       */
       delete: async () => connection.sendRequest("session.plan.delete", { sessionId })
     },
+    /** @experimental */
     workspaces: {
+      /**
+       * Gets current workspace metadata for the session.
+       *
+       * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
+       */
       getWorkspace: async () => connection.sendRequest("session.workspaces.getWorkspace", { sessionId }),
+      /**
+       * Lists files stored in the session workspace files directory.
+       *
+       * @returns Relative paths of files stored in the session workspace files directory.
+       */
       listFiles: async () => connection.sendRequest("session.workspaces.listFiles", { sessionId }),
+      /**
+       * Reads a file from the session workspace files directory.
+       *
+       * @param params Relative path of the workspace file to read.
+       *
+       * @returns Contents of the requested workspace file as a UTF-8 string.
+       */
       readFile: async (params) => connection.sendRequest("session.workspaces.readFile", { sessionId, ...params }),
-      createFile: async (params) => connection.sendRequest("session.workspaces.createFile", { sessionId, ...params })
+      /**
+       * Creates or overwrites a file in the session workspace files directory.
+       *
+       * @param params Relative path and UTF-8 content for the workspace file to create or overwrite.
+       */
+      createFile: async (params) => connection.sendRequest("session.workspaces.createFile", { sessionId, ...params }),
+      /**
+       * Lists workspace checkpoints in chronological order.
+       *
+       * @returns Workspace checkpoints in chronological order; empty when the workspace is not enabled.
+       */
+      listCheckpoints: async () => connection.sendRequest("session.workspaces.listCheckpoints", { sessionId }),
+      /**
+       * Reads the content of a workspace checkpoint by number.
+       *
+       * @param params Checkpoint number to read.
+       *
+       * @returns Checkpoint content as a UTF-8 string, or null when the checkpoint or workspace is missing.
+       */
+      readCheckpoint: async (params) => connection.sendRequest("session.workspaces.readCheckpoint", { sessionId, ...params }),
+      /**
+       * Saves pasted content as a UTF-8 file in the session workspace.
+       *
+       * @param 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.
+       */
+      saveLargePaste: async (params) => connection.sendRequest("session.workspaces.saveLargePaste", { sessionId, ...params })
     },
+    /** @experimental */
     instructions: {
+      /**
+       * Gets instruction sources loaded for the session.
+       *
+       * @returns Instruction sources loaded for the session, in merge order.
+       */
       getSources: async () => connection.sendRequest("session.instructions.getSources", { sessionId })
     },
     /** @experimental */
     fleet: {
+      /**
+       * Starts fleet mode by submitting the fleet orchestration prompt to the session.
+       *
+       * @param params Optional user prompt to combine with the fleet orchestration instructions.
+       *
+       * @returns Indicates whether fleet mode was successfully activated.
+       */
       start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
     },
     /** @experimental */
     agent: {
+      /**
+       * Lists custom agents available to the session.
+       *
+       * @returns Custom agents available to the session.
+       */
       list: async () => connection.sendRequest("session.agent.list", { sessionId }),
+      /**
+       * Gets the currently selected custom agent for the session.
+       *
+       * @returns The currently selected custom agent, or null when using the default agent.
+       */
       getCurrent: async () => connection.sendRequest("session.agent.getCurrent", { sessionId }),
+      /**
+       * Selects a custom agent for subsequent turns in the session.
+       *
+       * @param params Name of the custom agent to select for subsequent turns.
+       *
+       * @returns The newly selected custom agent.
+       */
       select: async (params) => connection.sendRequest("session.agent.select", { sessionId, ...params }),
+      /**
+       * Clears the selected custom agent and returns the session to the default agent.
+       */
       deselect: async () => connection.sendRequest("session.agent.deselect", { sessionId }),
+      /**
+       * Reloads custom agent definitions and returns the refreshed list.
+       *
+       * @returns Custom agents available to the session after reloading definitions from disk.
+       */
       reload: async () => connection.sendRequest("session.agent.reload", { sessionId })
     },
     /** @experimental */
     tasks: {
+      /**
+       * Starts a background agent task in the session.
+       *
+       * @param 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.
+       */
       startAgent: async (params) => connection.sendRequest("session.tasks.startAgent", { sessionId, ...params }),
+      /**
+       * Lists background tasks tracked by the session.
+       *
+       * @returns Background tasks currently tracked by the session.
+       */
       list: async () => connection.sendRequest("session.tasks.list", { sessionId }),
+      /**
+       * Refreshes metadata for any detached background shells the runtime knows about.
+       *
+       * @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.
+       */
+      refresh: async () => connection.sendRequest("session.tasks.refresh", { sessionId }),
+      /**
+       * Waits for all in-flight background tasks and any follow-up turns to settle.
+       *
+       * @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).
+       */
+      waitForPending: async () => connection.sendRequest("session.tasks.waitForPending", { sessionId }),
+      /**
+       * Returns progress information for a background task by ID.
+       *
+       * @param 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.
+       */
+      getProgress: async (params) => connection.sendRequest("session.tasks.getProgress", { sessionId, ...params }),
+      /**
+       * Returns the first sync-waiting task that can currently be promoted to background mode.
+       *
+       * @returns The first sync-waiting task that can currently be promoted to background mode.
+       */
+      getCurrentPromotable: async () => connection.sendRequest("session.tasks.getCurrentPromotable", { sessionId }),
+      /**
+       * Promotes an eligible synchronously-waited task so it continues running in the background.
+       *
+       * @param params Identifier of the task to promote to background mode.
+       *
+       * @returns Indicates whether the task was successfully promoted to background mode.
+       */
       promoteToBackground: async (params) => connection.sendRequest("session.tasks.promoteToBackground", { sessionId, ...params }),
+      /**
+       * Atomically promotes the first promotable sync-waiting task to background mode and returns it.
+       *
+       * @returns The promoted task as it now exists in background mode, omitted if no promotable task was waiting.
+       */
+      promoteCurrentToBackground: async () => connection.sendRequest("session.tasks.promoteCurrentToBackground", { sessionId }),
+      /**
+       * Cancels a background task.
+       *
+       * @param params Identifier of the background task to cancel.
+       *
+       * @returns Indicates whether the background task was successfully cancelled.
+       */
       cancel: async (params) => connection.sendRequest("session.tasks.cancel", { sessionId, ...params }),
-      remove: async (params) => connection.sendRequest("session.tasks.remove", { sessionId, ...params })
+      /**
+       * Removes a completed or cancelled background task from tracking.
+       *
+       * @param 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.
+       */
+      remove: async (params) => connection.sendRequest("session.tasks.remove", { sessionId, ...params }),
+      /**
+       * Sends a message to a background agent task.
+       *
+       * @param 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.
+       */
+      sendMessage: async (params) => connection.sendRequest("session.tasks.sendMessage", { sessionId, ...params })
     },
     /** @experimental */
     skills: {
+      /**
+       * Lists skills available to the session.
+       *
+       * @returns Skills available to the session, with their enabled state.
+       */
       list: async () => connection.sendRequest("session.skills.list", { sessionId }),
+      /**
+       * Returns the skills that have been invoked during this session.
+       *
+       * @returns Skills invoked during this session, ordered by invocation time (most recent last).
+       */
+      getInvoked: async () => connection.sendRequest("session.skills.getInvoked", { sessionId }),
+      /**
+       * Enables a skill for the session.
+       *
+       * @param params Name of the skill to enable for the session.
+       */
       enable: async (params) => connection.sendRequest("session.skills.enable", { sessionId, ...params }),
+      /**
+       * Disables a skill for the session.
+       *
+       * @param params Name of the skill to disable for the session.
+       */
       disable: async (params) => connection.sendRequest("session.skills.disable", { sessionId, ...params }),
-      reload: async () => connection.sendRequest("session.skills.reload", { sessionId })
+      /**
+       * Reloads skill definitions for the session.
+       *
+       * @returns Diagnostics from reloading skill definitions, with warnings and errors as separate lists.
+       */
+      reload: async () => connection.sendRequest("session.skills.reload", { sessionId }),
+      /**
+       * Ensures the session's skill definitions have been loaded from disk.
+       */
+      ensureLoaded: async () => connection.sendRequest("session.skills.ensureLoaded", { sessionId })
     },
     /** @experimental */
     mcp: {
+      /**
+       * Lists MCP servers configured for the session and their connection status.
+       *
+       * @returns MCP servers configured for the session, with their connection status.
+       */
       list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
+      /**
+       * Enables an MCP server for the session.
+       *
+       * @param params Name of the MCP server to enable for the session.
+       */
       enable: async (params) => connection.sendRequest("session.mcp.enable", { sessionId, ...params }),
+      /**
+       * Disables an MCP server for the session.
+       *
+       * @param params Name of the MCP server to disable for the session.
+       */
       disable: async (params) => connection.sendRequest("session.mcp.disable", { sessionId, ...params }),
+      /**
+       * Reloads MCP server connections for the session.
+       */
       reload: async () => connection.sendRequest("session.mcp.reload", { sessionId }),
+      /**
+       * Runs an MCP sampling inference on behalf of an MCP server.
+       *
+       * @param 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.
+       */
+      executeSampling: async (params) => connection.sendRequest("session.mcp.executeSampling", { sessionId, ...params }),
+      /**
+       * Cancels an in-flight MCP sampling execution by request ID.
+       *
+       * @param 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.
+       */
+      cancelSamplingExecution: async (params) => connection.sendRequest("session.mcp.cancelSamplingExecution", { sessionId, ...params }),
+      /**
+       * Sets how environment-variable values supplied to MCP servers are resolved (direct or indirect).
+       *
+       * @param params Mode controlling how MCP server env values are resolved (`direct` or `indirect`).
+       *
+       * @returns Env-value mode recorded on the session after the update.
+       */
+      setEnvValueMode: async (params) => connection.sendRequest("session.mcp.setEnvValueMode", { sessionId, ...params }),
+      /**
+       * Removes the auto-managed `github` MCP server when present.
+       *
+       * @returns Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).
+       */
+      removeGitHub: async () => connection.sendRequest("session.mcp.removeGitHub", { sessionId }),
       /** @experimental */
       oauth: {
+        /**
+         * Starts OAuth authentication for a remote MCP server.
+         *
+         * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, and the callback success-page copy.
+         *
+         * @returns OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
+         */
         login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params })
       }
     },
     /** @experimental */
     plugins: {
+      /**
+       * Lists plugins installed for the session.
+       *
+       * @returns Plugins installed for the session, with their enabled state and version metadata.
+       */
       list: async () => connection.sendRequest("session.plugins.list", { sessionId })
     },
     /** @experimental */
+    options: {
+      /**
+       * Patches the genuinely-mutable subset of session options.
+       *
+       * @param params Patch of mutable session options to apply to the running session.
+       *
+       * @returns Indicates whether the session options patch was applied successfully.
+       */
+      update: async (params) => connection.sendRequest("session.options.update", { sessionId, ...params })
+    },
+    /** @experimental */
+    lsp: {
+      /**
+       * Loads the merged LSP configuration set for the session's working directory.
+       *
+       * @param params Parameters for (re)loading the merged LSP configuration set.
+       */
+      initialize: async (params) => connection.sendRequest("session.lsp.initialize", { sessionId, ...params })
+    },
+    /** @experimental */
     extensions: {
+      /**
+       * Lists extensions discovered for the session and their current status.
+       *
+       * @returns Extensions discovered for the session, with their current status.
+       */
       list: async () => connection.sendRequest("session.extensions.list", { sessionId }),
+      /**
+       * Enables an extension for the session.
+       *
+       * @param params Source-qualified extension identifier to enable for the session.
+       */
       enable: async (params) => connection.sendRequest("session.extensions.enable", { sessionId, ...params }),
+      /**
+       * Disables an extension for the session.
+       *
+       * @param params Source-qualified extension identifier to disable for the session.
+       */
       disable: async (params) => connection.sendRequest("session.extensions.disable", { sessionId, ...params }),
+      /**
+       * Reloads extension definitions and processes for the session.
+       */
       reload: async () => connection.sendRequest("session.extensions.reload", { sessionId })
     },
+    /** @experimental */
     tools: {
-      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params })
+      /**
+       * Provides the result for a pending external tool call.
+       *
+       * @param 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.
+       */
+      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params }),
+      /**
+       * Resolves, builds, and validates the runtime tool list for the session.
+       *
+       * @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.
+       */
+      initializeAndValidate: async () => connection.sendRequest("session.tools.initializeAndValidate", { sessionId })
     },
+    /** @experimental */
     commands: {
-      handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params })
+      /**
+       * Lists slash commands available in the session.
+       *
+       * @param 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.
+       */
+      list: async (params) => connection.sendRequest("session.commands.list", { sessionId, ...params }),
+      /**
+       * Invokes a slash command in the session.
+       *
+       * @param 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, or completion).
+       */
+      invoke: async (params) => connection.sendRequest("session.commands.invoke", { sessionId, ...params }),
+      /**
+       * Reports completion of a pending client-handled slash command.
+       *
+       * @param 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.
+       */
+      handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params }),
+      /**
+       * Executes a slash command synchronously and returns any error.
+       *
+       * @param params Slash command name and argument string to execute synchronously.
+       *
+       * @returns Error message produced while executing the command, if any.
+       */
+      execute: async (params) => connection.sendRequest("session.commands.execute", { sessionId, ...params }),
+      /**
+       * Enqueues a slash command for FIFO processing on the local session.
+       *
+       * @param params Slash-prefixed command string to enqueue for FIFO processing.
+       *
+       * @returns Indicates whether the command was accepted into the local execution queue.
+       */
+      enqueue: async (params) => connection.sendRequest("session.commands.enqueue", { sessionId, ...params }),
+      /**
+       * Reports whether the host actually executed a queued command and whether to continue processing.
+       *
+       * @param 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.
+       */
+      respondToQueuedCommand: async (params) => connection.sendRequest("session.commands.respondToQueuedCommand", { sessionId, ...params })
+    },
+    /** @experimental */
+    telemetry: {
+      /**
+       * Sets feature override key/value pairs to attach to subsequent telemetry events for the session.
+       *
+       * @param params Feature override key/value pairs to attach to subsequent telemetry events from this session.
+       */
+      setFeatureOverrides: async (params) => connection.sendRequest("session.telemetry.setFeatureOverrides", { sessionId, ...params })
     },
+    /** @experimental */
     ui: {
+      /**
+       * Requests structured input from a UI-capable client.
+       *
+       * @param 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)
+       */
       elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params }),
-      handlePendingElicitation: async (params) => connection.sendRequest("session.ui.handlePendingElicitation", { sessionId, ...params })
+      /**
+       * Provides the user response for a pending elicitation request.
+       *
+       * @param 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.
+       */
+      handlePendingElicitation: async (params) => connection.sendRequest("session.ui.handlePendingElicitation", { sessionId, ...params }),
+      /**
+       * Resolves a pending `user_input.requested` event with the user's response.
+       *
+       * @param 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.
+       */
+      handlePendingUserInput: async (params) => connection.sendRequest("session.ui.handlePendingUserInput", { sessionId, ...params }),
+      /**
+       * Resolves a pending `sampling.requested` event with a sampling result, or rejects it.
+       *
+       * @param 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.
+       */
+      handlePendingSampling: async (params) => connection.sendRequest("session.ui.handlePendingSampling", { sessionId, ...params }),
+      /**
+       * Resolves a pending `auto_mode_switch.requested` event with the user's accept/decline decision.
+       *
+       * @param 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.
+       */
+      handlePendingAutoModeSwitch: async (params) => connection.sendRequest("session.ui.handlePendingAutoModeSwitch", { sessionId, ...params }),
+      /**
+       * Resolves a pending `exit_plan_mode.requested` event with the user's response.
+       *
+       * @param 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.
+       */
+      handlePendingExitPlanMode: async (params) => connection.sendRequest("session.ui.handlePendingExitPlanMode", { sessionId, ...params }),
+      /**
+       * Registers an in-process handler for auto-mode-switch requests so the server bridge skips dispatch.
+       *
+       * @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).
+       */
+      registerDirectAutoModeSwitchHandler: async () => connection.sendRequest("session.ui.registerDirectAutoModeSwitchHandler", { sessionId }),
+      /**
+       * Unregisters a previously-registered in-process auto-mode-switch handler by its opaque handle.
+       *
+       * @param params Opaque handle previously returned by `registerDirectAutoModeSwitchHandler` to release.
+       *
+       * @returns Indicates whether the handle was active and the registration count was decremented.
+       */
+      unregisterDirectAutoModeSwitchHandler: async (params) => connection.sendRequest("session.ui.unregisterDirectAutoModeSwitchHandler", { sessionId, ...params })
     },
+    /** @experimental */
     permissions: {
+      /**
+       * Replaces selected permission policy fields (rules, paths, URLs, exclusions, allow-all flags) on the session.
+       *
+       * @param params Patch of permission policy fields to apply (omit a field to leave it unchanged).
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
+      configure: async (params) => connection.sendRequest("session.permissions.configure", { sessionId, ...params }),
+      /**
+       * Provides a decision for a pending tool permission request.
+       *
+       * @param 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.
+       */
       handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params }),
+      /**
+       * Reconstructs the set of pending tool permission requests from the session's event history.
+       *
+       * @returns List of pending permission requests reconstructed from event history.
+       */
+      pendingRequests: async () => connection.sendRequest("session.permissions.pendingRequests", { sessionId }),
+      /**
+       * Enables or disables automatic approval of tool permission requests for the session.
+       *
+       * @param params Allow-all toggle for tool permission requests, with an optional telemetry source.
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
       setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { sessionId, ...params }),
-      resetSessionApprovals: async () => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId })
+      /**
+       * Adds or removes session-scoped or location-scoped permission rules.
+       *
+       * @param params Scope and add/remove instructions for modifying session- or location-scoped permission rules.
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
+      modifyRules: async (params) => connection.sendRequest("session.permissions.modifyRules", { sessionId, ...params }),
+      /**
+       * Sets whether the client wants permission prompts bridged into session events.
+       *
+       * @param params Toggles whether permission prompts should be bridged into session events for this client.
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
+      setRequired: async (params) => connection.sendRequest("session.permissions.setRequired", { sessionId, ...params }),
+      /**
+       * Clears session-scoped tool permission approvals.
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
+      resetSessionApprovals: async () => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId }),
+      /**
+       * Notifies the runtime that a permission prompt UI has been shown to the user.
+       *
+       * @param params Notification payload describing the permission prompt that the client just rendered.
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
+      notifyPromptShown: async (params) => connection.sendRequest("session.permissions.notifyPromptShown", { sessionId, ...params }),
+      /** @experimental */
+      paths: {
+        /**
+         * Returns the session's allowed directories and primary working directory.
+         *
+         * @returns Snapshot of the session's allow-listed directories and primary working directory.
+         */
+        list: async () => connection.sendRequest("session.permissions.paths.list", { sessionId }),
+        /**
+         * Adds a directory to the session's allow-list.
+         *
+         * @param params Directory path to add to the session's allowed directories.
+         *
+         * @returns Indicates whether the operation succeeded.
+         */
+        add: async (params) => connection.sendRequest("session.permissions.paths.add", { sessionId, ...params }),
+        /**
+         * Updates the session's primary working directory used by the permission policy.
+         *
+         * @param params Directory path to set as the session's new primary working directory.
+         *
+         * @returns Indicates whether the operation succeeded.
+         */
+        updatePrimary: async (params) => connection.sendRequest("session.permissions.paths.updatePrimary", { sessionId, ...params }),
+        /**
+         * Reports whether a path falls within any of the session's allowed directories.
+         *
+         * @param params Path to evaluate against the session's allowed directories.
+         *
+         * @returns Indicates whether the supplied path is within the session's allowed directories.
+         */
+        isPathWithinAllowedDirectories: async (params) => connection.sendRequest("session.permissions.paths.isPathWithinAllowedDirectories", { sessionId, ...params }),
+        /**
+         * Reports whether a path falls within the session's workspace (primary) directory.
+         *
+         * @param params Path to evaluate against the session's workspace (primary) directory.
+         *
+         * @returns Indicates whether the supplied path is within the session's workspace directory.
+         */
+        isPathWithinWorkspace: async (params) => connection.sendRequest("session.permissions.paths.isPathWithinWorkspace", { sessionId, ...params })
+      },
+      /** @experimental */
+      locations: {
+        /**
+         * Resolves the permission location key and type for a working directory.
+         *
+         * @param params Working directory to resolve into a location-permissions key.
+         *
+         * @returns Resolved location-permissions key and type.
+         */
+        resolve: async (params) => connection.sendRequest("session.permissions.locations.resolve", { sessionId, ...params }),
+        /**
+         * Applies persisted location-scoped tool approvals and allowed directories for a working directory to this session's permission service.
+         *
+         * @param params Working directory to load persisted location permissions for.
+         *
+         * @returns Summary of persisted location permissions applied to the session.
+         */
+        apply: async (params) => connection.sendRequest("session.permissions.locations.apply", { sessionId, ...params }),
+        /**
+         * Persists a tool approval for a permission location and applies its rules to this session's live permission service.
+         *
+         * @param params Location-scoped tool approval to persist.
+         *
+         * @returns Indicates whether the operation succeeded.
+         */
+        addToolApproval: async (params) => connection.sendRequest("session.permissions.locations.addToolApproval", { sessionId, ...params })
+      },
+      /** @experimental */
+      folderTrust: {
+        /**
+         * Reports whether a folder is trusted according to the user's folder trust state.
+         *
+         * @param params Folder path to check for trust.
+         *
+         * @returns Folder trust check result.
+         */
+        isTrusted: async (params) => connection.sendRequest("session.permissions.folderTrust.isTrusted", { sessionId, ...params }),
+        /**
+         * Adds a folder to the user's trusted folders list.
+         *
+         * @param params Folder path to add to trusted folders.
+         *
+         * @returns Indicates whether the operation succeeded.
+         */
+        addTrusted: async (params) => connection.sendRequest("session.permissions.folderTrust.addTrusted", { sessionId, ...params })
+      },
+      /** @experimental */
+      urls: {
+        /**
+         * Toggles the runtime's URL-permission policy between unrestricted and restricted modes.
+         *
+         * @param params Whether the URL-permission policy should run in unrestricted mode.
+         *
+         * @returns Indicates whether the operation succeeded.
+         */
+        setUnrestrictedMode: async (params) => connection.sendRequest("session.permissions.urls.setUnrestrictedMode", { sessionId, ...params })
+      }
     },
+    /**
+     * Emits a user-visible session log event.
+     *
+     * @param 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.
+     *
+     * @experimental
+     */
     log: async (params) => connection.sendRequest("session.log", { sessionId, ...params }),
+    /** @experimental */
+    metadata: {
+      /**
+       * Returns a snapshot of the session's identifying metadata, mode, agent, and remote info.
+       *
+       * @returns Point-in-time snapshot of slow-changing session identifier and state fields
+       */
+      snapshot: async () => connection.sendRequest("session.metadata.snapshot", { sessionId }),
+      /**
+       * Reports whether the local session is currently processing user/agent messages.
+       *
+       * @returns Indicates whether the local session is currently processing a turn or background continuation.
+       */
+      isProcessing: async () => connection.sendRequest("session.metadata.isProcessing", { sessionId }),
+      /**
+       * Returns the token breakdown for the session's current context window for a given model.
+       *
+       * @param 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.
+       */
+      contextInfo: async (params) => connection.sendRequest("session.metadata.contextInfo", { sessionId, ...params }),
+      /**
+       * Records a working-directory/git context change and emits a `session.context_changed` event.
+       *
+       * @param 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).
+       */
+      recordContextChange: async (params) => connection.sendRequest("session.metadata.recordContextChange", { sessionId, ...params }),
+      /**
+       * Updates the session's recorded working directory.
+       *
+       * @param params Absolute path to set as the session's new working directory.
+       *
+       * @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 `process.chdir` and any related side-effects (file index, etc.); this method only updates the session's own recorded path.
+       */
+      setWorkingDirectory: async (params) => connection.sendRequest("session.metadata.setWorkingDirectory", { sessionId, ...params }),
+      /**
+       * Re-tokenizes the session's existing messages against a model and returns aggregate token totals.
+       *
+       * @param 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.
+       */
+      recomputeContextTokens: async (params) => connection.sendRequest("session.metadata.recomputeContextTokens", { sessionId, ...params })
+    },
+    /** @experimental */
     shell: {
+      /**
+       * Starts a shell command and streams output through session notifications.
+       *
+       * @param 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.
+       */
       exec: async (params) => connection.sendRequest("session.shell.exec", { sessionId, ...params }),
+      /**
+       * Sends a signal to a shell process previously started via "shell.exec".
+       *
+       * @param 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.
+       */
       kill: async (params) => connection.sendRequest("session.shell.kill", { sessionId, ...params })
     },
     /** @experimental */
     history: {
+      /**
+       * Compacts the session history to reduce context usage.
+       *
+       * @returns Compaction outcome with the number of tokens and messages removed, summary text, and the resulting context window breakdown.
+       */
       compact: async () => connection.sendRequest("session.history.compact", { sessionId }),
-      truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params })
+      /**
+       * Truncates persisted session history to a specific event.
+       *
+       * @param 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.
+       */
+      truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params }),
+      /**
+       * Cancels any in-progress background compaction on a local session.
+       *
+       * @returns Indicates whether an in-progress background compaction was cancelled.
+       */
+      cancelBackgroundCompaction: async () => connection.sendRequest("session.history.cancelBackgroundCompaction", { sessionId }),
+      /**
+       * Aborts any in-progress manual compaction on a local session.
+       *
+       * @returns Indicates whether an in-progress manual compaction was aborted.
+       */
+      abortManualCompaction: async () => connection.sendRequest("session.history.abortManualCompaction", { sessionId }),
+      /**
+       * Produces a markdown summary of the session's conversation context for hand-off scenarios.
+       *
+       * @returns Markdown summary of the conversation context (empty when not available).
+       */
+      summarizeForHandoff: async () => connection.sendRequest("session.history.summarizeForHandoff", { sessionId })
+    },
+    /** @experimental */
+    queue: {
+      /**
+       * Returns the local session's pending user-facing queued items and steering messages.
+       *
+       * @returns Snapshot of the session's pending queued items and immediate-steering messages.
+       */
+      pendingItems: async () => connection.sendRequest("session.queue.pendingItems", { sessionId }),
+      /**
+       * Removes the most recently queued user-facing item (LIFO).
+       *
+       * @returns Indicates whether a user-facing pending item was removed.
+       */
+      removeMostRecent: async () => connection.sendRequest("session.queue.removeMostRecent", { sessionId }),
+      /**
+       * Clears all pending queued items on the local session.
+       */
+      clear: async () => connection.sendRequest("session.queue.clear", { sessionId })
+    },
+    /** @experimental */
+    eventLog: {
+      /**
+       * Reads a batch of session events from a cursor, optionally waiting for new events.
+       *
+       * @param 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.
+       */
+      read: async (params) => connection.sendRequest("session.eventLog.read", { sessionId, ...params }),
+      /**
+       * Returns a snapshot of the current tail cursor without consuming events.
+       *
+       * @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).
+       */
+      tail: async () => connection.sendRequest("session.eventLog.tail", { sessionId }),
+      /**
+       * Registers consumer interest in an event type for runtime gating purposes.
+       *
+       * @param params Event type to register consumer interest for, used by runtime gating logic.
+       *
+       * @returns Opaque handle representing an event-type interest registration.
+       */
+      registerInterest: async (params) => connection.sendRequest("session.eventLog.registerInterest", { sessionId, ...params }),
+      /**
+       * Releases a consumer's previously-registered interest in an event type.
+       *
+       * @param params Opaque handle previously returned by `registerInterest` to release.
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
+      releaseInterest: async (params) => connection.sendRequest("session.eventLog.releaseInterest", { sessionId, ...params })
     },
     /** @experimental */
     usage: {
+      /**
+       * Gets accumulated usage metrics for the session.
+       *
+       * @returns Accumulated session usage metrics, including premium request cost, token counts, model breakdown, and code-change totals.
+       */
       getMetrics: async () => connection.sendRequest("session.usage.getMetrics", { sessionId })
     },
     /** @experimental */
     remote: {
-      enable: async () => connection.sendRequest("session.remote.enable", { sessionId }),
-      disable: async () => connection.sendRequest("session.remote.disable", { sessionId })
+      /**
+       * Enables remote session export or steering.
+       *
+       * @param 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.
+       */
+      enable: async (params) => connection.sendRequest("session.remote.enable", { sessionId, ...params }),
+      /**
+       * Disables remote session export and steering.
+       */
+      disable: async () => connection.sendRequest("session.remote.disable", { sessionId }),
+      /**
+       * Persists a remote-steerability change emitted by the host as a session event.
+       *
+       * @param 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.
+       */
+      notifySteerableChanged: async (params) => connection.sendRequest("session.remote.notifySteerableChanged", { sessionId, ...params })
+    },
+    /** @experimental */
+    schedule: {
+      /**
+       * Lists the session's currently active scheduled prompts.
+       *
+       * @returns Snapshot of the currently active recurring prompts for this session.
+       */
+      list: async () => connection.sendRequest("session.schedule.list", { sessionId }),
+      /**
+       * Removes a scheduled prompt by id.
+       *
+       * @param 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.
+       */
+      stop: async (params) => connection.sendRequest("session.schedule.stop", { sessionId, ...params })
     }
   };
 }
@@ -209,6 +1326,16 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
     return handler.rename(params);
   });
+  connection.onRequest("sessionFs.sqliteQuery", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.sqliteQuery(params);
+  });
+  connection.onRequest("sessionFs.sqliteExists", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.sqliteExists(params);
+  });
 }
 export {
   createInternalServerRpc,