@github/copilot-sdk 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/generated/rpc.js

@@ -1,155 +1,1447 @@
 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)
     },
+    secrets: {
+      /**
+       * Registers secret values for redaction in session logs and exports. The SDK calls this to inject dynamically generated secret values (e.g., OIDC tokens).
+       *
+       * @param params Secret values to add to the redaction filter.
+       *
+       * @returns Confirmation that the secret values were registered.
+       */
+      addFilterValues: async (params) => connection.sendRequest("secrets.addFilterValues", 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),
-        disable: async (params) => connection.sendRequest("mcp.config.disable", 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),
+        /**
+         * Drops this runtime process's in-memory MCP server-definition cache so the next MCP config read observes disk.
+         */
+        reload: async () => connection.sendRequest("mcp.config.reload", {})
       },
+      /**
+       * 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)
     },
+    user: {
+      settings: {
+        /**
+         * Drops this runtime process's in-memory user settings cache so the next settings read observes disk.
+         */
+        reload: async () => connection.sendRequest("user.settings.reload", {})
+      }
+    },
+    runtime: {
+      /**
+       * Gracefully shuts down an SDK-owned runtime. The response is sent only after cleanup completes; callers may then terminate the owned runtime process.
+       */
+      shutdown: async () => connection.sendRequest("runtime.shutdown", {})
+    },
     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 filters 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 enriched metadata records, with summary and context fields backfilled where available. Sessions confirmed empty and unnamed are omitted.
+       */
+      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)
+    },
+    /** @experimental */
+    agentRegistry: {
+      /**
+       * Spawns a managed-server child with the supplied configuration and returns a discriminated-union result. The caller (typically the CLI controller) is responsible for attaching to the spawned child and sending any follow-up prompt. When the controller-local spawn gate is closed the server returns JSON-RPC MethodNotFound.
+       *
+       * @param params Inputs to spawn a managed-server child via the controller's spawn delegate.
+       *
+       * @returns Outcome of an agentRegistry.spawn call.
+       */
+      spawn: async (params) => connection.sendRequest("agentRegistry.spawn", 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 */
+    canvas: {
+      /**
+       * Lists canvases declared for the session.
+       *
+       * @returns Declared canvases available in this session.
+       */
+      list: async () => connection.sendRequest("session.canvas.list", { sessionId }),
+      /**
+       * Lists currently open canvas instances for the live session.
+       *
+       * @returns Live open-canvas snapshot.
+       */
+      listOpen: async () => connection.sendRequest("session.canvas.listOpen", { sessionId }),
+      /**
+       * Opens or focuses a canvas instance.
+       *
+       * @param params Canvas open parameters.
+       *
+       * @returns Open canvas instance snapshot.
+       */
+      open: async (params) => connection.sendRequest("session.canvas.open", { sessionId, ...params }),
+      /**
+       * Closes an open canvas instance.
+       *
+       * @param params Canvas close parameters.
+       */
+      close: async (params) => connection.sendRequest("session.canvas.close", { sessionId, ...params }),
+      /** @experimental */
+      action: {
+        /**
+         * Invokes an action on an open canvas instance.
+         *
+         * @param params Canvas action invocation parameters.
+         *
+         * @returns Canvas action invocation result.
+         */
+        invoke: async (params) => connection.sendRequest("session.canvas.action.invoke", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
     model: {
+      /**
+       * Gets the currently selected model for the session.
+       *
+       * @returns The currently selected model, reasoning effort, and context tier for the session. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.
+       */
       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, capability overrides, and context tier.
+       *
+       * @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 }),
+      /**
+       * Lists models available to this session using its own auth and integration context. Connected hosts (CLI TUI, GitHub App) should call this through the session client so remote sessions return the remote CLI's available models rather than the caller's.
+       *
+       * @param params Optional listing options.
+       *
+       * @returns The list of models available to this session.
+       */
+      list: async (params) => connection.sendRequest("session.model.list", { 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 }),
+      /**
+       * Computes a diff for the session workspace.
+       *
+       * @param params Parameters for computing a workspace diff.
+       *
+       * @returns Workspace diff result for the requested mode.
+       */
+      diff: async (params) => connection.sendRequest("session.workspaces.diff", { 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 */
+      apps: {
+        /**
+         * Fetch an MCP resource (typically a `ui://` MCP App bundle, per SEP-1865) from a connected server. Requires the `mcp-apps` session capability.
+         *
+         * @param params MCP server and resource URI to fetch.
+         *
+         * @returns Resource contents returned by the MCP server.
+         */
+        readResource: async (params) => connection.sendRequest("session.mcp.apps.readResource", { sessionId, ...params }),
+        /**
+         * List tools that an MCP App view is allowed to call (SEP-1865 visibility filter). Returns tools whose `_meta.ui.visibility` is unset (default `["model","app"]`) or includes `"app"`.
+         *
+         * @param params MCP server to list app-callable tools for.
+         *
+         * @returns App-callable tools from the named MCP server.
+         */
+        listTools: async (params) => connection.sendRequest("session.mcp.apps.listTools", { sessionId, ...params }),
+        /**
+         * Call an MCP tool from an MCP App view (SEP-1865). Enforces the visibility check that prevents an app iframe from invoking model-only tools. Returns the standard MCP `CallToolResult`.
+         *
+         * @param params MCP server, tool name, and arguments to invoke from an MCP App view.
+         *
+         * @returns Standard MCP CallToolResult
+         */
+        callTool: async (params) => connection.sendRequest("session.mcp.apps.callTool", { sessionId, ...params }),
+        /**
+         * Replace the host context returned to MCP App guests on `ui/initialize`. Hosts use this to advertise theme, locale, or other metadata to the guest UI.
+         *
+         * @param params Host context to advertise to MCP App guests.
+         */
+        setHostContext: async (params) => connection.sendRequest("session.mcp.apps.setHostContext", { sessionId, ...params }),
+        /**
+         * Read the current host context advertised to MCP App guests.
+         *
+         * @returns Current host context advertised to MCP App guests.
+         */
+        getHostContext: async () => connection.sendRequest("session.mcp.apps.getHostContext", { sessionId }),
+        /**
+         * Diagnose MCP Apps wiring for a specific MCP server. Reports the session capability, feature-flag state, advertised extension, and how many tools have `_meta.ui` populated.
+         *
+         * @param params MCP server to diagnose MCP Apps wiring for.
+         *
+         * @returns Diagnostic snapshot of MCP Apps wiring for the named server.
+         */
+        diagnose: async (params) => connection.sendRequest("session.mcp.apps.diagnose", { 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 }),
-      reload: async () => connection.sendRequest("session.extensions.reload", { sessionId })
+      /**
+       * Reloads extension definitions and processes for the session.
+       */
+      reload: async () => connection.sendRequest("session.extensions.reload", { sessionId }),
+      /**
+       * Push attachments into the next user-message turn from an extension. The host should surface them as composer pills and forward them via the next session.send call. Callable only by extension-owned connections.
+       *
+       * @param params Parameters for session.extensions.sendAttachmentsToMessage.
+       */
+      sendAttachmentsToMessage: async (params) => connection.sendRequest("session.extensions.sendAttachmentsToMessage", { sessionId, ...params })
     },
+    /** @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 }),
+      /**
+       * Returns lightweight metadata for the session's currently initialized tools.
+       *
+       * @returns Current lightweight tool metadata snapshot for the session.
+       */
+      getCurrentMetadata: async () => connection.sendRequest("session.tools.getCurrentMetadata", { 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 })
+      /**
+       * Enables or disables full allow-all permissions (tools, paths, and URLs) for the session. Used by attach-mode clients (e.g. LocalRpcSession's `/allow-all` forwarder) to flip the target session's permission state. Unlike `setApproveAll`, this swaps in the unrestricted path and URL managers and emits `session.permissions_changed` on transition. The result returns the authoritative post-mutation state so callers can update their local mirrors without racing the `session.permissions_changed` notification on the same wire.
+       *
+       * @param params Whether to enable full allow-all permissions for the session.
+       *
+       * @returns Indicates whether the operation succeeded and reports the post-mutation state.
+       */
+      setAllowAll: async (params) => connection.sendRequest("session.permissions.setAllowAll", { sessionId, ...params }),
+      /**
+       * Returns whether full allow-all permissions are currently active for the session.
+       *
+       * @returns Current full allow-all permission state.
+       */
+      getAllowAll: async () => connection.sendRequest("session.permissions.getAllowAll", { 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: {
-      compact: async () => connection.sendRequest("session.history.compact", { sessionId }),
-      truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params })
+      /**
+       * Compacts the session history to reduce context usage.
+       *
+       * @param params Optional compaction parameters.
+       *
+       * @returns Compaction outcome with the number of tokens and messages removed, summary text, and the resulting context window breakdown.
+       */
+      compact: async (params) => connection.sendRequest("session.history.compact", { 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: {
+      /**
+       * 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 })
     }
   };
 }
@@ -204,6 +1496,31 @@ 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);
+  });
+  connection.onRequest("canvas.open", async (params) => {
+    const handler = getHandlers(params.sessionId).canvas;
+    if (!handler) throw new Error(`No canvas handler registered for session: ${params.sessionId}`);
+    return handler.open(params);
+  });
+  connection.onRequest("canvas.close", async (params) => {
+    const handler = getHandlers(params.sessionId).canvas;
+    if (!handler) throw new Error(`No canvas handler registered for session: ${params.sessionId}`);
+    return handler.close(params);
+  });
+  connection.onRequest("canvas.action.invoke", async (params) => {
+    const handler = getHandlers(params.sessionId).canvas;
+    if (!handler) throw new Error(`No canvas handler registered for session: ${params.sessionId}`);
+    return handler.invoke(params);
+  });
 }
 export {
   createInternalServerRpc,