@github/copilot-sdk 1.0.0-beta.9 → 1.0.1

package/dist/generated/rpc.js

@@ -85,7 +85,11 @@ function createServerRpc(connection) {
          *
          * @param params MCP server names to disable for new sessions.
          */
-        disable: async (params) => connection.sendRequest("mcp.config.disable", params)
+        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.
@@ -96,6 +100,96 @@ function createServerRpc(connection) {
        */
       discover: async (params) => connection.sendRequest("mcp.discover", params)
     },
+    /** @experimental */
+    plugins: {
+      /**
+       * Lists plugins installed in user/global state.
+       *
+       * @returns Plugins installed in user/global state.
+       */
+      list: async () => connection.sendRequest("plugins.list", {}),
+      /**
+       * Installs a plugin from a marketplace, GitHub repo, URL, or local path.
+       *
+       * @param params Plugin source and optional working directory for relative-path resolution.
+       *
+       * @returns Result of installing a plugin.
+       */
+      install: async (params) => connection.sendRequest("plugins.install", params),
+      /**
+       * Uninstalls an installed plugin.
+       *
+       * @param params Name (or spec) of the plugin to uninstall.
+       */
+      uninstall: async (params) => connection.sendRequest("plugins.uninstall", params),
+      /**
+       * Updates an installed plugin to its latest published version.
+       *
+       * @param params Name (or spec) of the plugin to update.
+       *
+       * @returns Result of updating a single plugin.
+       */
+      update: async (params) => connection.sendRequest("plugins.update", params),
+      /**
+       * Updates every installed plugin to its latest published version.
+       *
+       * @returns Result of updating all installed plugins.
+       */
+      updateAll: async () => connection.sendRequest("plugins.updateAll", {}),
+      /**
+       * Enables installed plugins for new sessions.
+       *
+       * @param params Plugin names (or specs) to enable.
+       */
+      enable: async (params) => connection.sendRequest("plugins.enable", params),
+      /**
+       * Disables installed plugins for new sessions.
+       *
+       * @param params Plugin names (or specs) to disable.
+       */
+      disable: async (params) => connection.sendRequest("plugins.disable", params),
+      /** @experimental */
+      marketplaces: {
+        /**
+         * Lists all registered marketplaces (defaults + user-added).
+         *
+         * @returns All registered marketplaces, including built-in defaults.
+         */
+        list: async () => connection.sendRequest("plugins.marketplaces.list", {}),
+        /**
+         * Registers a new marketplace from a source (owner/repo, URL, or local path).
+         *
+         * @param params Marketplace source to register.
+         *
+         * @returns Result of registering a new marketplace.
+         */
+        add: async (params) => connection.sendRequest("plugins.marketplaces.add", params),
+        /**
+         * Removes a previously-registered marketplace. When the marketplace has dependent plugins and `force` is not set, the marketplace is left intact and the result lists the dependents so the caller can decide whether to retry with `force=true`.
+         *
+         * @param params Name of the marketplace to remove and an optional force flag.
+         *
+         * @returns Outcome of the remove attempt, including dependent-plugin info when applicable.
+         */
+        remove: async (params) => connection.sendRequest("plugins.marketplaces.remove", params),
+        /**
+         * Lists plugins advertised by a registered marketplace.
+         *
+         * @param params Name of the marketplace whose plugin catalog to fetch.
+         *
+         * @returns Plugins advertised by the marketplace.
+         */
+        browse: async (params) => connection.sendRequest("plugins.marketplaces.browse", params),
+        /**
+         * Re-fetches one or all registered marketplace catalogs.
+         *
+         * @param params Optional marketplace name; omit to refresh all.
+         *
+         * @returns Result of refreshing one or more marketplace catalogs.
+         */
+        refresh: async (params) => connection.sendRequest("plugins.marketplaces.refresh", params)
+      }
+    },
     skills: {
       config: {
         /**
@@ -114,6 +208,42 @@ function createServerRpc(connection) {
        */
       discover: async (params) => connection.sendRequest("skills.discover", params)
     },
+    /** @experimental */
+    agents: {
+      /**
+       * Discovers custom agents across user, project, plugin, and remote sources.
+       *
+       * @param params Optional project paths to include in agent discovery.
+       *
+       * @returns Agents discovered across user, project, plugin, and remote sources.
+       */
+      discover: async (params) => connection.sendRequest("agents.discover", params)
+    },
+    /** @experimental */
+    instructions: {
+      /**
+       * Discovers instruction sources across user, repository, and plugin sources.
+       *
+       * @param params Optional project paths to include in instruction discovery.
+       *
+       * @returns Instruction sources discovered across user, repository, and plugin sources.
+       */
+      discover: async (params) => connection.sendRequest("instructions.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.
@@ -126,6 +256,14 @@ function createServerRpc(connection) {
     },
     /** @experimental */
     sessions: {
+      /**
+       * Creates or resumes a local session and returns the opened session ID.
+       *
+       * @param params Open a session by creating, resuming, attaching, connecting to a remote, or handing off.
+       *
+       * @returns Result of opening a session.
+       */
+      open: async (params) => connection.sendRequest("sessions.open", params),
       /**
        * Creates a new session by forking persisted history from an existing session.
        *
@@ -143,11 +281,11 @@ function createServerRpc(connection) {
        */
       connect: async (params) => connection.sendRequest("sessions.connect", params),
       /**
-       * Lists persisted sessions, optionally filtered by working-directory context.
+       * Lists sessions, optionally filtered by source and working-directory context. Returned entries are discriminated by `isRemote`: local entries carry only the lightweight `LocalSessionMetadataValue` shape; remote entries carry the full `RemoteSessionMetadataValue` shape (repository, PR number, taskType, etc.).
        *
-       * @param params Optional metadata-load limit and filters applied to the returned sessions.
+       * @param params Optional source filter, metadata-load limit, and context filter applied to the returned sessions.
        *
-       * @returns Persisted sessions matching the filter, ordered most-recently-modified first.
+       * @returns Sessions matching the filter, ordered most-recently-modified first.
        */
       list: async (params) => connection.sendRequest("sessions.list", params),
       /**
@@ -174,14 +312,6 @@ function createServerRpc(connection) {
        * @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.
        *
@@ -196,14 +326,6 @@ function createServerRpc(connection) {
        * @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.
        *
@@ -275,7 +397,45 @@ function createServerRpc(connection) {
        *
        * @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)
+      setAdditionalPlugins: async (params) => connection.sendRequest("sessions.setAdditionalPlugins", params),
+      /**
+       * Attaches the runtime-managed remote-control singleton to a session, awaiting initial setup. If remote control is already attached to a different session, the singleton is transferred (preserving the underlying Mission Control connection). Returns the final status.
+       *
+       * @param params Parameters for attaching the remote-control singleton to a session.
+       *
+       * @returns Wrapper for the singleton's current status.
+       */
+      startRemoteControl: async (params) => connection.sendRequest("sessions.startRemoteControl", params),
+      /**
+       * Atomically rebinds the remote-control singleton to a different session, preserving the underlying Mission Control connection. When `expectedFromSessionId` is provided and does not match the singleton's current `attachedSessionId`, the transfer is rejected with `transferred: false` and the current status is returned unchanged.
+       *
+       * @param params Parameters for atomically rebinding the remote-control singleton.
+       *
+       * @returns Outcome of a transferRemoteControl call.
+       */
+      transferRemoteControl: async (params) => connection.sendRequest("sessions.transferRemoteControl", params),
+      /**
+       * Patches the steering state of the active remote-control singleton. When remote control is off, this is a no-op and the off status is returned. Today only `enabled: true` is actionable on the underlying exporter; passing `false` is reserved for future use.
+       *
+       * @param params Patch for the singleton's steering state.
+       *
+       * @returns Wrapper for the singleton's current status.
+       */
+      setRemoteControlSteering: async (params) => connection.sendRequest("sessions.setRemoteControlSteering", params),
+      /**
+       * Stops the remote-control singleton. When `expectedSessionId` is provided and does not match the singleton's current `attachedSessionId`, the stop is rejected with `stopped: false` and the current status is returned unchanged (unless `force` is set, in which case the singleton is unconditionally torn down).
+       *
+       * @param params Parameters for stopping the remote-control singleton.
+       *
+       * @returns Outcome of a stopRemoteControl call.
+       */
+      stopRemoteControl: async (params) => connection.sendRequest("sessions.stopRemoteControl", params),
+      /**
+       * Returns the current state of the remote-control singleton, including the attached session id and frontend URL when active.
+       *
+       * @returns Wrapper for the singleton's current status.
+       */
+      getRemoteControlStatus: async () => connection.sendRequest("sessions.getRemoteControlStatus", {})
     },
     /** @experimental */
     agentRegistry: {
@@ -293,13 +453,62 @@ function createServerRpc(connection) {
 function createInternalServerRpc(connection) {
   return {
     /**
-     * Performs the SDK server connection handshake and validates the optional connection token.
+     * Performs the SDK server connection handshake and validates the optional connection token. Marked internal because this is JSON-RPC transport plumbing invoked automatically by an SDK client's own `connect()` wrapper, not a user-facing method. Stays internal as long as the SDK client owns the handshake; would only become public if the SDK ever exposed the raw schema surface to consumers without a connection wrapper.
      *
      * @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)
+    connect: async (params) => connection.sendRequest("connect", params),
+    /** @experimental */
+    sessions: {
+      /**
+       * Computes the absolute path to a session's persisted events.jsonl file. Internal: filesystem paths are only meaningful in-process (CLI and runtime share a filesystem). Currently used by the CLI's contribution-graph feature to read historical events directly. Remote SDK consumers must not depend on this; a proper event-query API would replace it if the contribution graph ever needed to work over the wire.
+       *
+       * @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 a session's persisted remote-steerable flag, if any has been recorded. Internal: this is CLI-specific book-keeping used by `--continue` / `--resume` to inherit the prior session's remote-steerable preference. SDK consumers that want similar behavior should manage their own persistence around start/stop calls rather than relying on this runtime-side flag.
+       *
+       * @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),
+      /**
+       * Gets the dynamic-context board entry count associated with a session, when available. Internal: this exists solely so CLI telemetry events (`rem_spawn_gate`, `rem_consolidation_complete`) can pair START / END board counts around the detached rem-agent spawn. "Dynamic context board" is a runtime-internal concept that is not part of the public SDK contract; the long-term plan is to relocate the telemetry emission into the runtime so this method can be deleted entirely.
+       *
+       * @param params Session ID whose board entry count should be returned.
+       *
+       * @returns Dynamic-context board entry count, when available.
+       */
+      getBoardEntryCount: async (params) => connection.sendRequest("sessions.getBoardEntryCount", params),
+      /**
+       * Cursor-based long-poll for sessions spawned by the runtime (e.g. in response to a Mission Control `start_session` command). The cursor is an opaque token; pass it back to receive only spawn events that occurred AFTER the cursor was issued. Omit the cursor on the first call to receive any events buffered since the runtime started. Internal: this is a CLI background-daemon plumbing primitive. SDK consumers that need to react to runtime-spawned sessions should subscribe to a higher-level event stream rather than driving a long-poll loop.
+       *
+       * @param params Cursor and optional long-poll wait for polling runtime-spawned sessions.
+       *
+       * @returns Batch of spawn events plus a cursor for follow-up polls.
+       */
+      pollSpawnedSessions: async (params) => connection.sendRequest("sessions.pollSpawnedSessions", params),
+      /**
+       * Registers extension-provided tools on the given session, gated by an optional `enabled` callback. Returns an opaque unsubscribe function the caller must invoke to deregister the tools when the extension is torn down. Marked internal because `loader`, `enabled`, and the returned `unsubscribe` are in-process handles that cannot cross the JSON-RPC boundary. Disappears once extension discovery / launch / tool registration are owned by the runtime: SDK consumers will pass pure config (search paths, disabled ids) via `SessionOptions` and the runtime will resolve, launch, register, and tear down extensions itself.
+       *
+       * @param params Params to attach an extension loader's tools to a session.
+       *
+       * @returns Handle for releasing the extension tool registration.
+       */
+      registerExtensionToolsOnSession: async (params) => connection.sendRequest("sessions.registerExtensionToolsOnSession", params),
+      /**
+       * Attaches (or detaches) an in-process ExtensionController delegate for the given session, used by shared-API surfaces that need to query or modify the session's extension state. Pass `controller: undefined` to detach. Marked internal because the controller is an in-process object that cannot cross the JSON-RPC boundary. Disappears alongside `registerExtensionToolsOnSession`: once the runtime owns extension management, the public surface exposes list/enable/disable/reload as dedicated RPCs served by the runtime.
+       *
+       * @param params Params to attach or detach an in-process ExtensionController delegate.
+       */
+      configureSessionExtensions: async (params) => connection.sendRequest("sessions.configureSessionExtensions", params)
+    }
   };
 }
 function createSessionRpc(connection, sessionId) {
@@ -383,27 +592,30 @@ function createSessionRpc(connection, sessionId) {
        * @param params Canvas close parameters.
        */
       close: async (params) => connection.sendRequest("session.canvas.close", { sessionId, ...params }),
-      /**
-       * Invokes an action on an open canvas instance.
-       *
-       * @param params Canvas action invocation parameters.
-       *
-       * @returns Canvas action invocation result.
-       */
-      invokeAction: async (params) => connection.sendRequest("session.canvas.invokeAction", { 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 and reasoning effort 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 }),
       /**
        * Switches the session to a model and optional reasoning configuration.
        *
-       * @param params Target model identifier and optional reasoning effort, summary, and capability overrides.
+       * @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.
        */
@@ -415,7 +627,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 })
+      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: {
@@ -472,7 +692,13 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Deletes the session plan file from the workspace.
        */
-      delete: async () => connection.sendRequest("session.plan.delete", { sessionId })
+      delete: async () => connection.sendRequest("session.plan.delete", { sessionId }),
+      /**
+       * Reads todo rows from the session SQL database for plan rendering.
+       *
+       * @returns Todo rows read from the session SQL database. Empty when no session database is available.
+       */
+      readSqlTodos: async () => connection.sendRequest("session.plan.readSqlTodos", { sessionId })
     },
     /** @experimental */
     workspaces: {
@@ -707,11 +933,19 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     mcp: {
       /**
-       * Lists MCP servers configured for the session and their connection status.
+       * Lists MCP servers configured for the session, their connection status, and host-level state. The host-level state (disabled/filtered servers, failed/needs-auth/pending connections, mcp3p policy, full config) is empty/zero when no MCP host has been initialized for the session.
        *
-       * @returns MCP servers configured for the session, with their connection status.
+       * @returns MCP servers configured for the session, with their connection status and host-level state.
        */
       list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
+      /**
+       * Lists the tools exposed by a connected MCP server on this session's host.
+       *
+       * @param params Server name whose tool list should be returned.
+       *
+       * @returns Tools exposed by the connected MCP server. Throws when the server is not connected.
+       */
+      listTools: async (params) => connection.sendRequest("session.mcp.listTools", { sessionId, ...params }),
       /**
        * Enables an MCP server for the session.
        *
@@ -758,6 +992,20 @@ function createSessionRpc(connection, sessionId) {
        * @returns Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).
        */
       removeGitHub: async () => connection.sendRequest("session.mcp.removeGitHub", { sessionId }),
+      /**
+       * Stops an individual MCP server on the session's host.
+       *
+       * @param params Server name for an individual MCP server stop.
+       */
+      stopServer: async (params) => connection.sendRequest("session.mcp.stopServer", { sessionId, ...params }),
+      /**
+       * Checks whether a named MCP server is currently running on the session's host.
+       *
+       * @param params Server name to check running status for.
+       *
+       * @returns Whether the named MCP server is running.
+       */
+      isServerRunning: async (params) => connection.sendRequest("session.mcp.isServerRunning", { sessionId, ...params }),
       /** @experimental */
       oauth: {
         /**
@@ -824,7 +1072,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Plugins installed for the session, with their enabled state and version metadata.
        */
-      list: async () => connection.sendRequest("session.plugins.list", { sessionId })
+      list: async () => connection.sendRequest("session.plugins.list", { sessionId }),
+      /**
+       * Reloads the session's plugin set, refreshing MCP servers, custom agents, hooks, and skills cache so SDK-driven changes via `server.plugins.*` take effect immediately.
+       *
+       * @param params Optional flags controlling which side effects the reload performs.
+       */
+      reload: async (params) => connection.sendRequest("session.plugins.reload", { sessionId, ...params })
     },
     /** @experimental */
     options: {
@@ -869,7 +1123,13 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Reloads extension definitions and processes for the session.
        */
-      reload: async () => connection.sendRequest("session.extensions.reload", { sessionId })
+      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: {
@@ -886,7 +1146,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 })
+      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: {
@@ -941,6 +1207,12 @@ function createSessionRpc(connection, sessionId) {
     },
     /** @experimental */
     telemetry: {
+      /**
+       * Gets the telemetry engagement ID currently associated with the session, when available.
+       *
+       * @returns Telemetry engagement ID for the session, when available.
+       */
+      getEngagementId: async () => connection.sendRequest("session.telemetry.getEngagementId", { sessionId }),
       /**
        * Sets feature override key/value pairs to attach to subsequent telemetry events for the session.
        *
@@ -950,6 +1222,14 @@ function createSessionRpc(connection, sessionId) {
     },
     /** @experimental */
     ui: {
+      /**
+       * Runs a transient no-tools model query against the current conversation context.
+       *
+       * @param params Transient question to answer without adding it to conversation history.
+       *
+       * @returns Transient answer generated from current conversation context.
+       */
+      ephemeralQuery: async (params) => connection.sendRequest("session.ui.ephemeralQuery", { sessionId, ...params }),
       /**
        * Requests structured input from a UI-capable client.
        *
@@ -1212,6 +1492,12 @@ function createSessionRpc(connection, sessionId) {
        * @returns Indicates whether the local session is currently processing a turn or background continuation.
        */
       isProcessing: async () => connection.sendRequest("session.metadata.isProcessing", { sessionId }),
+      /**
+       * Returns a snapshot of activity flags for the session.
+       *
+       * @returns Current activity flags for the session.
+       */
+      activity: async () => connection.sendRequest("session.metadata.activity", { sessionId }),
       /**
        * Returns the token breakdown for the session's current context window for a given model.
        *
@@ -1262,7 +1548,23 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 })
+      kill: async (params) => connection.sendRequest("session.shell.kill", { sessionId, ...params }),
+      /**
+       * Executes a user-requested shell command through the session runtime.
+       *
+       * @param params User-requested shell command and cancellation handle.
+       *
+       * @returns Result of a user-requested shell command.
+       */
+      executeUserRequested: async (params) => connection.sendRequest("session.shell.executeUserRequested", { sessionId, ...params }),
+      /**
+       * Cancels a user-requested shell command by request ID.
+       *
+       * @param params User-requested shell execution cancellation handle.
+       *
+       * @returns Cancellation result for a user-requested shell command.
+       */
+      cancelUserRequested: async (params) => connection.sendRequest("session.shell.cancelUserRequested", { sessionId, ...params })
     },
     /** @experimental */
     history: {
@@ -1404,6 +1706,64 @@ function createSessionRpc(connection, sessionId) {
     }
   };
 }
+function createInternalSessionRpc(connection, sessionId) {
+  return {
+    /** @experimental */
+    mcp: {
+      /**
+       * Reloads MCP server connections for the session with an explicit host-provided configuration.
+       *
+       * @param params Opaque MCP reload configuration.
+       *
+       * @returns MCP server startup filtering result.
+       */
+      reloadWithConfig: async (params) => connection.sendRequest("session.mcp.reloadWithConfig", { sessionId, ...params }),
+      /**
+       * Configures the built-in GitHub MCP server for the session's current auth context.
+       *
+       * @param params Opaque auth info used to configure GitHub MCP.
+       *
+       * @returns Result of configuring GitHub MCP.
+       */
+      configureGitHub: async (params) => connection.sendRequest("session.mcp.configureGitHub", { sessionId, ...params }),
+      /**
+       * Starts an individual MCP server on the session's host.
+       *
+       * @param params Server name and opaque configuration for an individual MCP server start.
+       */
+      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
+      /**
+       * Restarts an individual MCP server on the session's host (stops then starts).
+       *
+       * @param params Server name and opaque configuration for an individual MCP server restart.
+       */
+      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { sessionId, ...params }),
+      /**
+       * Registers a pre-connected external MCP client (e.g. IDE) on the session's host. The caller retains lifecycle ownership of the client and transport. Marked internal because the `client` and `transport` arguments are in-process MCP SDK instances that cannot be serialized across the JSON-RPC boundary; once the CLI moves on top of the SDK, external clients will be expressed as transport configs the runtime can construct itself.
+       *
+       * @param params Registration parameters for an external MCP client.
+       */
+      registerExternalClient: async (params) => connection.sendRequest("session.mcp.registerExternalClient", { sessionId, ...params }),
+      /**
+       * Unregisters a previously registered external MCP client by server name. Marked internal as the paired companion of `registerExternalClient`: only in-process callers that registered a client this way can meaningfully unregister it. Disappears alongside `registerExternalClient`: once external clients are described to the runtime as config rather than handed in as instances, lifecycle (including deregistration) is owned entirely by the runtime.
+       *
+       * @param params Server name identifying the external client to remove.
+       */
+      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params }),
+      /** @experimental */
+      oauth: {
+        /**
+         * Responds to a pending MCP OAuth provider request. Marked internal because the `provider` argument is an in-process OAuthClientProvider instance that cannot be carried over the wire; the public OAuth surface will route the response through a wire-clean handshake once the CLI moves on top of the SDK.
+         *
+         * @param params MCP OAuth request id and optional provider response.
+         *
+         * @returns Empty result after recording the MCP OAuth response.
+         */
+        respond: async (params) => connection.sendRequest("session.mcp.oauth.respond", { sessionId, ...params })
+      }
+    }
+  };
+}
 function registerClientSessionApiHandlers(connection, getHandlers) {
   connection.onRequest("sessionFs.readFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
@@ -1475,14 +1835,15 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No canvas handler registered for session: ${params.sessionId}`);
     return handler.close(params);
   });
-  connection.onRequest("canvas.invokeAction", async (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.invokeAction(params);
+    return handler.invoke(params);
   });
 }
 export {
   createInternalServerRpc,
+  createInternalSessionRpc,
   createServerRpc,
   createSessionRpc,
   registerClientSessionApiHandlers