@github/copilot-sdk 1.0.0 → 1.0.2-preview.0

package/dist/cjs/generated/rpc.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var rpc_exports = {};
 __export(rpc_exports, {
   createInternalServerRpc: () => createInternalServerRpc,
+  createInternalSessionRpc: () => createInternalSessionRpc,
   createServerRpc: () => createServerRpc,
   createSessionRpc: () => createSessionRpc,
   registerClientSessionApiHandlers: () => registerClientSessionApiHandlers
@@ -126,6 +127,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: {
         /**
@@ -142,7 +233,55 @@ function createServerRpc(connection) {
        *
        * @returns Skills discovered across global and project sources.
        */
-      discover: async (params) => connection.sendRequest("skills.discover", params)
+      discover: async (params) => connection.sendRequest("skills.discover", params),
+      /**
+       * Returns the canonical directories where a client may create skills that the runtime will recognize, including ones that do not exist yet. Project directories become active once created.
+       *
+       * @param params Optional project paths to enumerate.
+       *
+       * @returns Canonical locations where skills can be created so the runtime will recognize them.
+       *
+       * @experimental
+       */
+      getDiscoveryPaths: async (params) => connection.sendRequest("skills.getDiscoveryPaths", 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),
+      /**
+       * Returns the canonical directories where a client may create custom agents that the runtime will recognize, including ones that do not exist yet. Project directories become active once created.
+       *
+       * @param params Optional project paths to include when enumerating agent discovery directories.
+       *
+       * @returns Canonical locations where custom agents can be created so the runtime will recognize them.
+       */
+      getDiscoveryPaths: async (params) => connection.sendRequest("agents.getDiscoveryPaths", 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),
+      /**
+       * Returns the canonical files and directories where a client may create custom instructions that the runtime will recognize, including ones that do not exist yet. Repository targets become active once created.
+       *
+       * @param params Optional project paths to include when enumerating instruction discovery targets.
+       *
+       * @returns Canonical files and directories where custom instructions can be created so the runtime will recognize them.
+       */
+      getDiscoveryPaths: async (params) => connection.sendRequest("instructions.getDiscoveryPaths", params)
     },
     user: {
       settings: {
@@ -170,6 +309,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.
        *
@@ -187,11 +334,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),
       /**
@@ -218,14 +365,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.
        *
@@ -240,14 +379,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.
        *
@@ -319,7 +450,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: {
@@ -337,13 +506,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) {
@@ -527,7 +745,19 @@ 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 }),
+      /**
+       * Reads todo rows AND dependency edges from the session SQL database for structured progress UI. Same defensive behavior as readSqlTodos — returns empty arrays when the database, tables, or columns aren't available. Clients should call this on session start and after every `session.todos_changed` event to refresh structured-UI rendering.
+       *
+       * @returns Todo rows + dependency edges read from the session SQL database.
+       */
+      readSqlTodosWithDependencies: async () => connection.sendRequest("session.plan.readSqlTodosWithDependencies", { sessionId })
     },
     /** @experimental */
     workspaces: {
@@ -762,11 +992,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.
        *
@@ -813,6 +1051,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: {
         /**
@@ -879,7 +1131,24 @@ 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 */
+    provider: {
+      /**
+       * Returns the provider endpoint and credentials the session is currently configured to talk to, so the caller can make inference calls directly against the same backend the session uses.
+       *
+       * @param params Optional model identifier to scope the endpoint snapshot to.
+       *
+       * @returns A snapshot of the provider endpoint the session is currently configured to talk to.
+       */
+      getEndpoint: async (params) => connection.sendRequest("session.provider.getEndpoint", { sessionId, ...params })
     },
     /** @experimental */
     options: {
@@ -953,7 +1222,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Current lightweight tool metadata snapshot for the session.
        */
-      getCurrentMetadata: async () => connection.sendRequest("session.tools.getCurrentMetadata", { sessionId })
+      getCurrentMetadata: async () => connection.sendRequest("session.tools.getCurrentMetadata", { sessionId }),
+      /**
+       * Updates the current session's live subagent settings after user settings change. The persisted user settings remain the source of truth for future sessions.
+       *
+       * @param params Subagent settings to apply to the current session
+       *
+       * @returns Empty result after applying subagent settings
+       */
+      updateSubagentSettings: async (params) => connection.sendRequest("session.tools.updateSubagentSettings", { sessionId, ...params })
     },
     /** @experimental */
     commands: {
@@ -1008,6 +1285,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.
        *
@@ -1017,6 +1300,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.
        *
@@ -1279,6 +1570,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.
        *
@@ -1329,7 +1626,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: {
@@ -1471,6 +1784,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;
@@ -1551,6 +1922,7 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createInternalServerRpc,
+  createInternalSessionRpc,
   createServerRpc,
   createSessionRpc,
   registerClientSessionApiHandlers

package/dist/cjs/session.js

@@ -56,6 +56,9 @@ class CopilotSession {
     this._workspacePath = _workspacePath;
     this.traceContextProvider = traceContextProvider;
   }
+  sessionId;
+  connection;
+  _workspacePath;
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
@@ -276,6 +279,8 @@ class CopilotSession {
       this._capabilities = { ...this._capabilities, ...event.data };
     } else if (event.type === "session.canvas.opened") {
       this.upsertOpenCanvasFromEvent(event.data);
+    } else if (event.type === "session.canvas.closed") {
+      this.removeOpenCanvasFromEvent(event.data);
     }
   }
   upsertOpenCanvasFromEvent(data) {
@@ -285,6 +290,18 @@ class CopilotSession {
     }
     this.upsertOpenCanvas(data);
   }
+  removeOpenCanvasFromEvent(data) {
+    if (!data || typeof data !== "object" || typeof data.instanceId !== "string" || data.instanceId.length === 0) {
+      console.warn("failed to deserialize session.canvas.closed payload");
+      return;
+    }
+    this.removeOpenCanvas(data.instanceId);
+  }
+  removeOpenCanvas(instanceId) {
+    this.openCanvasInstances = this.openCanvasInstances.filter(
+      (open) => open.instanceId !== instanceId
+    );
+  }
   upsertOpenCanvas(instance) {
     const index = this.openCanvasInstances.findIndex(
       (open) => open.instanceId === instance.instanceId
@@ -576,8 +593,8 @@ class CopilotSession {
   /**
    * Snapshot of canvas instances currently known to be open for this session.
    * Populated from the `session.resume` response and live `session.canvas.opened`
-   * events. Returns a defensive copy — mutating the returned array has no effect
-   * on the session.
+   * and `session.canvas.closed` events. Returns a defensive copy — mutating the
+   * returned array has no effect on the session.
    */
   get openCanvases() {
     return [...this.openCanvasInstances];

package/dist/client.d.ts

@@ -72,6 +72,7 @@ export declare class CopilotClient {
      * @throws Error if the client is not connected
      */
     get rpc(): ReturnType<typeof createServerRpc>;
+    private logDebugTiming;
     /**
      * Creates a new CopilotClient instance.
      *
@@ -132,8 +133,9 @@ export declare class CopilotClient {
      *
      * This method performs graceful cleanup:
      * 1. Closes all active sessions (releases in-memory resources)
-     * 2. Closes the JSON-RPC connection
-     * 3. Terminates the CLI server process (if spawned by this client)
+     * 2. Requests runtime shutdown for SDK-owned CLI processes
+     * 3. Closes the JSON-RPC connection
+     * 4. Terminates the CLI server process (if spawned by this client)
      *
      * Note: session data on disk is preserved, so sessions can be resumed later.
      * To permanently remove session data before stopping, call