@github/copilot-language-server 1.528.0 → 1.530.0

package/dist/node_modules/@github/copilot-sdk/dist/cjs/generated/rpc.js

@@ -47,7 +47,13 @@ function createServerRpc(connection) {
        *
        * @returns List of Copilot models available to the resolved user, including capabilities and billing metadata.
        */
-      list: async (params) => connection.sendRequest("models.list", params)
+      list: async (params) => connection.sendRequest("models.list", params),
+      /**
+       * Returns the running runtime's complete catalog of well-known built-in model IDs without authentication or network access.
+       *
+       * @returns The running runtime's complete catalog of well-known built-in model IDs, including supported models and additional IDs with built-in metadata.
+       */
+      getBuiltInCatalog: async () => connection.sendRequest("models.getBuiltInCatalog", {})
     },
     /** @experimental */
     tools: {
@@ -165,6 +171,27 @@ function createServerRpc(connection) {
       discover: async (params) => connection.sendRequest("mcp.discover", params)
     },
     /** @experimental */
+    extensions: {
+      /**
+       * Discovers user and enabled installed-plugin extensions from persisted Copilot home state, including enablement preferences. Launch-scoped additional plugins are not included.
+       *
+       * @returns Extensions discovered from persisted Copilot home state and their effective loading mode. Launch-scoped additional plugins are not included.
+       */
+      discover: async () => connection.sendRequest("extensions.discover", {}),
+      /**
+       * Persistently enables extension IDs for future sessions. Active sessions are unchanged; use session.extensions.enable to update them.
+       *
+       * @param params Source-qualified extension identifiers to persistently enable for future sessions.
+       */
+      enable: async (params) => connection.sendRequest("extensions.enable", params),
+      /**
+       * Persistently disables extension IDs for future sessions. Active sessions are unchanged; use session.extensions.disable to update them.
+       *
+       * @param params Source-qualified extension identifiers to persistently disable for future sessions.
+       */
+      disable: async (params) => connection.sendRequest("extensions.disable", params)
+    },
+    /** @experimental */
     plugins: {
       /**
        * Lists plugins installed in user/global state.
@@ -223,7 +250,7 @@ function createServerRpc(connection) {
         /**
          * Registers a new marketplace from a source (owner/repo, URL, or local path).
          *
-         * @param params Marketplace source to register.
+         * @param params Marketplace source and optional working directory for relative-path resolution.
          *
          * @returns Result of registering a new marketplace.
          */
@@ -321,6 +348,15 @@ function createServerRpc(connection) {
       getDiscoveryPaths: async (params) => connection.sendRequest("instructions.getDiscoveryPaths", params)
     },
     /** @experimental */
+    commands: {
+      /**
+       * Lists the well-known built-in slash commands that work as the first message in a new session (e.g. /plan, /env), without requiring an active session. Commands that depend on session state, authentication, or a synced session are omitted.
+       *
+       * @returns Slash commands available in the session, after applying any include/exclude filters.
+       */
+      list: async () => connection.sendRequest("commands.list", {})
+    },
+    /** @experimental */
     user: {
       /** @experimental */
       settings: {
@@ -588,7 +624,7 @@ function createInternalServerRpc(connection) {
     /**
      * 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.
+     * @param params Parameters for the `server.connect` handshake: an optional connection token and optional connection-level opt-ins (e.g. GitHub telemetry forwarding).
      *
      * @returns Handshake result reporting the server's protocol version and package version on success.
      *
@@ -597,6 +633,22 @@ function createInternalServerRpc(connection) {
     connect: async (params) => connection.sendRequest("connect", params),
     /** @experimental */
     sessions: {
+      /**
+       * Reads lightweight persisted metadata for one local session without opening it.
+       *
+       * @param params Session ID whose persisted metadata should be read.
+       *
+       * @returns Persisted local session metadata when the session exists.
+       */
+      getMetadata: async (params) => connection.sendRequest("sessions.getMetadata", params),
+      /**
+       * Lists recent local session IDs that contain user-visible history, omitting housekeeping-only sessions.
+       *
+       * @param params Limit for non-empty local session IDs.
+       *
+       * @returns Recent local session IDs that contain user-visible history.
+       */
+      listNonEmptySessionIds: async (params) => connection.sendRequest("sessions.listNonEmptySessionIds", params),
       /**
        * 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.
        *
@@ -613,6 +665,12 @@ function createInternalServerRpc(connection) {
        * @returns The session's persisted remote-steerable flag, or omitted when no value has been persisted.
        */
       getPersistedRemoteSteerable: async (params) => connection.sendRequest("sessions.getPersistedRemoteSteerable", params),
+      /**
+       * Deletes one local session from disk after running the same lifecycle hooks as the session manager.
+       *
+       * @param params Session ID to delete from disk.
+       */
+      delete: async (params) => connection.sendRequest("sessions.delete", 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.
        *
@@ -656,6 +714,16 @@ function createSessionRpc(connection, sessionId) {
      * @experimental
      */
     send: async (params) => connection.sendRequest("session.send", { sessionId, ...params }),
+    /**
+     * Sends zero or more user messages to the session in a single turn and returns their message IDs. All provided messages are appended to the conversation in order, then exactly one agent turn runs over the resulting history. When the list is empty, one turn runs over the existing history with no new user message. Remote-backed (Mission Control) sessions do not support this method and will return an error.
+     *
+     * @param params Parameters for sending zero or more user messages to the session in a single turn. Remote-backed (Mission Control) sessions do not support this method and will return an error.
+     *
+     * @returns Result of sending zero or more user messages
+     *
+     * @experimental
+     */
+    sendMessages: async (params) => connection.sendRequest("session.sendMessages", { sessionId, ...params }),
     /**
      * Aborts the current agent turn.
      *
@@ -666,6 +734,24 @@ function createSessionRpc(connection, sessionId) {
      * @experimental
      */
     abort: async (params) => connection.sendRequest("session.abort", { sessionId, ...params }),
+    /**
+     * Interrupts the current main agent turn while leaving running background work (subagents, sidekicks, and promoted attached shells) alive. No-op when the main loop is not processing.
+     *
+     * @param params Parameters for interrupting the main agent turn.
+     *
+     * @returns Result of interrupting the main agent turn.
+     *
+     * @experimental
+     */
+    interruptMainTurn: async (params) => connection.sendRequest("session.interruptMainTurn", { sessionId, ...params }),
+    /**
+     * Cancels every running background agent (task-registry subagents plus sidekick agents) without interrupting the main agent loop. Promoted attached shells are left running.
+     *
+     * @returns The number of running background agents (task-registry agents) that were cancelled.
+     *
+     * @experimental
+     */
+    cancelAllBackgroundAgents: async () => connection.sendRequest("session.cancelAllBackgroundAgents", { sessionId }),
     /**
      * 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.
      *
@@ -692,6 +778,17 @@ function createSessionRpc(connection, sessionId) {
       setCredentials: async (params) => connection.sendRequest("session.gitHubAuth.setCredentials", { sessionId, ...params })
     },
     /** @experimental */
+    debug: {
+      /**
+       * Collects a redacted session debug log bundle into a local archive or staging directory. The runtime includes session-owned logs by default and accepts caller-provided diagnostic entries so host applications can add their own files without changing this API shape.
+       *
+       * @param params Options for collecting a redacted session debug bundle.
+       *
+       * @returns Result of collecting a redacted debug bundle.
+       */
+      collectLogs: async (params) => connection.sendRequest("session.debug.collectLogs", { sessionId, ...params })
+    },
+    /** @experimental */
     canvas: {
       /**
        * Lists canvases declared for the session.
@@ -732,6 +829,98 @@ function createSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
+    factory: {
+      /**
+       * Runs a registered factory by name at the top level.
+       *
+       * @param params Parameters for invoking a registered factory.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      run: async (params) => connection.sendRequest("session.factory.run", { sessionId, ...params }),
+      /**
+       * Resumes a factory run using its persisted name, arguments, journal, and accounting.
+       *
+       * @param params Parameters for resuming a factory run from its persisted identity.
+       *
+       * @returns Resolved persisted factory identity and resumed run envelope.
+       */
+      resume: async (params) => connection.sendRequest("session.factory.resume", { sessionId, ...params }),
+      /**
+       * Gets the current or settled envelope for a factory run.
+       *
+       * @param params Parameters for retrieving a factory run.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      getRun: async (params) => connection.sendRequest("session.factory.getRun", { sessionId, ...params }),
+      /**
+       * Lists durable factory runs for this session in creation order.
+       *
+       * @returns Factory runs in durable creation order.
+       */
+      listRuns: async () => connection.sendRequest("session.factory.listRuns", { sessionId }),
+      /**
+       * Gets durable and live observability detail for one factory run.
+       *
+       * @param params Parameters for retrieving a factory run.
+       *
+       * @returns Full factory run observability detail.
+       */
+      getRunDetail: async (params) => connection.sendRequest("session.factory.getRunDetail", { sessionId, ...params }),
+      /**
+       * Pages durable progress for one factory run.
+       *
+       * @param params Parameters for paging factory progress.
+       *
+       * @returns A bidirectional page of factory progress.
+       */
+      getRunProgress: async (params) => connection.sendRequest("session.factory.getRunProgress", { sessionId, ...params }),
+      /**
+       * Requests cancellation of a factory run and returns its run envelope.
+       *
+       * @param params Parameters for cancelling a factory run.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
+      /**
+       * Records a batch of ordered factory progress lines.
+       *
+       * @param params Parameters for recording factory progress.
+       *
+       * @returns Acknowledgement that a factory request was accepted.
+       */
+      log: async (params) => connection.sendRequest("session.factory.log", { sessionId, ...params }),
+      /**
+       * Runs one factory-scoped subagent and returns its result.
+       *
+       * @param params Parameters for one factory-scoped subagent call.
+       *
+       * @returns Result of one factory-scoped subagent call.
+       */
+      agent: async (params) => connection.sendRequest("session.factory.agent", { sessionId, ...params }),
+      /** @experimental */
+      journal: {
+        /**
+         * Reads a memoized factory journal entry.
+         *
+         * @param params Parameters for reading a factory journal entry.
+         *
+         * @returns Result of reading a factory journal entry.
+         */
+        get: async (params) => connection.sendRequest("session.factory.journal.get", { sessionId, ...params }),
+        /**
+         * Stores a memoized factory journal entry.
+         *
+         * @param params Parameters for storing a factory journal entry.
+         *
+         * @returns Acknowledgement that a factory request was accepted.
+         */
+        put: async (params) => connection.sendRequest("session.factory.journal.put", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
     model: {
       /**
        * Gets the currently selected model for the session.
@@ -841,6 +1030,22 @@ function createSessionRpc(connection, sessionId) {
        * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
        */
       getWorkspace: async () => connection.sendRequest("session.workspaces.getWorkspace", { sessionId }),
+      /**
+       * Updates workspace metadata for a local session and returns the refreshed workspace.
+       *
+       * @param params Workspace metadata fields to update.
+       *
+       * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
+       */
+      updateMetadata: async (params) => connection.sendRequest("session.workspaces.updateMetadata", { sessionId, ...params }),
+      /**
+       * Ensures a local session workspace exists and returns it.
+       *
+       * @param params Optional session context used when creating a local workspace.
+       *
+       * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
+       */
+      ensure: async (params) => connection.sendRequest("session.workspaces.ensure", { sessionId, ...params }),
       /**
        * Lists files stored in the session workspace files directory.
        *
@@ -875,6 +1080,48 @@ function createSessionRpc(connection, sessionId) {
        * @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 }),
+      /**
+       * Adds a compaction summary checkpoint to the local session workspace.
+       *
+       * @param params Compaction summary checkpoint to persist.
+       *
+       * @returns Persisted summary metadata and refreshed workspace metadata.
+       */
+      addSummary: async (params) => connection.sendRequest("session.workspaces.addSummary", { sessionId, ...params }),
+      /**
+       * Truncates local workspace compaction summaries after a rollback.
+       *
+       * @param params Rollback point for local workspace summaries.
+       *
+       * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
+       */
+      truncateSummaries: async (params) => connection.sendRequest("session.workspaces.truncateSummaries", { sessionId, ...params }),
+      /**
+       * Reads the autopilot objective state file from the local session workspace.
+       *
+       * @returns Autopilot objective file content, or null when missing.
+       */
+      readAutopilotObjective: async () => connection.sendRequest("session.workspaces.readAutopilotObjective", { sessionId }),
+      /**
+       * Writes the autopilot objective state file in the local session workspace.
+       *
+       * @param params Autopilot objective file content to persist.
+       *
+       * @returns Result of writing the autopilot objective file.
+       */
+      writeAutopilotObjective: async (params) => connection.sendRequest("session.workspaces.writeAutopilotObjective", { sessionId, ...params }),
+      /**
+       * Deletes the autopilot objective state file from the local session workspace.
+       *
+       * @returns Result of deleting the autopilot objective file.
+       */
+      deleteAutopilotObjective: async () => connection.sendRequest("session.workspaces.deleteAutopilotObjective", { sessionId }),
+      /**
+       * Checks whether the local session workspace has an autopilot objective state file.
+       *
+       * @returns Whether the autopilot objective file exists.
+       */
+      autopilotObjectiveExists: async () => connection.sendRequest("session.workspaces.autopilotObjectiveExists", { sessionId }),
       /**
        * Saves pasted content as a UTF-8 file in the session workspace.
        *
@@ -884,7 +1131,7 @@ function createSessionRpc(connection, sessionId) {
        */
       saveLargePaste: async (params) => connection.sendRequest("session.workspaces.saveLargePaste", { sessionId, ...params }),
       /**
-       * Computes a diff for the session workspace.
+       * Computes a diff for the session workspace. Never rejects for a busy session: a `session`-mode diff that cannot read the session's file-change captures falls back to an unstaged git diff with `isFallback: true` and reports why in `unavailableReason`.
        *
        * @param params Parameters for computing a workspace diff.
        *
@@ -932,11 +1179,19 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     agent: {
       /**
-       * Lists custom agents available to the session.
+       * Lists agents available to the session. Defaults to custom agents only; pass includeBuiltInAgents to include the effective built-in agents.
        *
-       * @returns Custom agents available to the session.
+       * @param params Controls whether built-in agents and authored prompt text are included.
+       *
+       * @returns Agents available to the session.
        */
-      list: async () => connection.sendRequest("session.agent.list", { sessionId }),
+      list: async (params) => connection.sendRequest("session.agent.list", { sessionId, ...params }),
+      /**
+       * Sets an in-memory authored prompt override for an available agent. For built-in agents, this replaces only the static base prompt while preserving runtime-owned dynamic prompt composition and behavior. The special `general-purpose` agent is not overrideable. Overrides are not persisted; resumed and forked sessions start without them, so the host must re-apply them.
+       *
+       * @param params An in-memory authored prompt override for an available agent.
+       */
+      setPrompt: async (params) => connection.sendRequest("session.agent.setPrompt", { sessionId, ...params }),
       /**
        * Gets the currently selected custom agent for the session.
        *
@@ -1089,7 +1344,7 @@ function createSessionRpc(connection, sessionId) {
        */
       list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
       /**
-       * Lists the tools exposed by a connected MCP server on this session's host.
+       * Lists the tools exposed by a connected MCP server on this session's host. This performs a live `tools/list` request. Tool UI metadata is returned independently of whether MCP Apps rendering is enabled for the session.
        *
        * @param params Server name whose tool list should be returned.
        *
@@ -1142,6 +1397,18 @@ 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 }),
+      /**
+       * Starts an individual MCP server on the live session. Omit `config` for a config-free start-by-name of an already-configured server (reuses the server's already-registered configuration); supply `config` to start from a caller-supplied configuration. Session-scoped and ephemeral: the server is added to this session's running set only and is reaped when the session ends. Does NOT modify persistent user configuration (`mcp.config.*`), so it does not affect future sessions. The server surfaces through `session.mcp.list` and the `session.mcp_servers_loaded` / `session.mcp_server_status_changed` events like any other server.
+       *
+       * @param params Server name and optional configuration for an individual MCP server start. Omit `config` for a config-free start-by-name of an already-configured server.
+       */
+      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
+      /**
+       * Restarts an individual MCP server on the live session (stops then starts). Omit `config` for a config-free restart-by-name of an already-configured server; supply `config` to restart with a replacement configuration. Session-scoped and ephemeral: does NOT modify persistent user configuration (`mcp.config.*`).
+       *
+       * @param params Server name and optional replacement configuration for an individual MCP server restart. Omit `config` for a config-free restart-by-name of an already-configured server.
+       */
+      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { sessionId, ...params }),
       /**
        * Stops an individual MCP server on the session's host.
        *
@@ -1166,6 +1433,12 @@ function createSessionRpc(connection, sessionId) {
          * @returns Indicates whether the pending MCP OAuth response was accepted.
          */
         handlePendingRequest: async (params) => connection.sendRequest("session.mcp.oauth.handlePendingRequest", { sessionId, ...params }),
+        /**
+         * Notifies the session that MCP OAuth authentication succeeded and updated credentials were persisted, so cached tool definitions can be refreshed.
+         *
+         * @param params Identifies the MCP server whose persisted OAuth credentials were updated.
+         */
+        authenticationStateChanged: async (params) => connection.sendRequest("session.mcp.oauth.authenticationStateChanged", { sessionId, ...params }),
         /**
          * Starts OAuth authentication for a remote MCP server.
          *
@@ -1173,7 +1446,15 @@ function createSessionRpc(connection, sessionId) {
          *
          * @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 })
+        login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params }),
+        /**
+         * Responds to a pending MCP OAuth authorization request by its request id.
+         *
+         * @param params Pending MCP OAuth request id to respond to.
+         *
+         * @returns Indicates whether the pending MCP OAuth response was accepted.
+         */
+        respond: async (params) => connection.sendRequest("session.mcp.oauth.respond", { sessionId, ...params })
       },
       /** @experimental */
       headers: {
@@ -1232,6 +1513,33 @@ function createSessionRpc(connection, sessionId) {
          * @returns Diagnostic snapshot of MCP Apps wiring for the named server.
          */
         diagnose: async (params) => connection.sendRequest("session.mcp.apps.diagnose", { sessionId, ...params })
+      },
+      /** @experimental */
+      resources: {
+        /**
+         * Fetch an MCP resource from a connected server by URI (proxies MCP `resources/read`).
+         *
+         * @param params MCP server and resource URI to fetch.
+         *
+         * @returns Resource contents returned by the MCP server.
+         */
+        read: async (params) => connection.sendRequest("session.mcp.resources.read", { sessionId, ...params }),
+        /**
+         * Enumerate one page of resources a connected MCP server exposes (proxies MCP `resources/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
+         *
+         * @param params MCP server whose resources to enumerate.
+         *
+         * @returns One page of resources advertised by the named MCP server.
+         */
+        list: async (params) => connection.sendRequest("session.mcp.resources.list", { sessionId, ...params }),
+        /**
+         * Enumerate one page of resource templates a connected MCP server exposes (proxies MCP `resources/templates/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
+         *
+         * @param params MCP server whose resource templates to enumerate.
+         *
+         * @returns One page of resource templates advertised by the named MCP server.
+         */
+        listTemplates: async (params) => connection.sendRequest("session.mcp.resources.listTemplates", { sessionId, ...params })
       }
     },
     /** @experimental */
@@ -1530,17 +1838,17 @@ function createSessionRpc(connection, sessionId) {
        */
       setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { sessionId, ...params }),
       /**
-       * 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.
+       * Sets the allow-all permission mode for the session. Used by attach-mode clients (e.g. LocalRpcSession's `/allow-all` forwarder) to flip the target session's permission state. The `on` mode swaps in unrestricted path and URL managers and emits `session.permissions_changed` on transition; the `auto` mode keeps normal prompt paths active while attaching LLM safety recommendations. 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.
+       * @param params Allow-all mode to apply 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 the current allow-all permission mode for the session.
        *
-       * @returns Current full allow-all permission state.
+       * @returns Current allow-all permission mode.
        */
       getAllowAll: async () => connection.sendRequest("session.permissions.getAllowAll", { sessionId }),
       /**
@@ -1562,9 +1870,11 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Clears session-scoped tool permission approvals.
        *
+       * @param params Clears session-scoped tool permission approvals, and optionally the location-scoped ones.
+       *
        * @returns Indicates whether the operation succeeded.
        */
-      resetSessionApprovals: async () => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId }),
+      resetSessionApprovals: async (params) => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId, ...params }),
       /**
        * Notifies the runtime that a permission prompt UI has been shown to the user.
        *
@@ -1725,19 +2035,19 @@ function createSessionRpc(connection, sessionId) {
        */
       getContextHeaviestMessages: async (params) => connection.sendRequest("session.metadata.getContextHeaviestMessages", { sessionId, ...params }),
       /**
-       * Records a working-directory/git context change and emits a `session.context_changed` event.
+       * Records a working-directory/git context change and emits a `session.context_changed` event. For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event): a local session's working directory is authoritative and is moved via `metadata.setWorkingDirectory` (or an SDK `session.resume` that supplies a `workingDirectory`), not by this method.
        *
        * @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).
+       * @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). For a local session, a report whose `cwd` diverges from the session's current working directory is ignored (the call still succeeds but records nothing and emits no event); move a local session's working directory via `metadata.setWorkingDirectory` instead.
        */
       recordContextChange: async (params) => connection.sendRequest("session.metadata.recordContextChange", { sessionId, ...params }),
       /**
-       * Updates the session's recorded working directory.
+       * Updates the session's working directory. For local sessions the target is validated first (an absolute path that exists on disk) and the permission primary directory is re-based; a rejected validation fails the call before any session state changes.
        *
-       * @param params Absolute path to set as the session's new working directory.
+       * @param params Absolute path to set as the session's new working directory. For local sessions the path must be absolute and exist on disk: it is validated before any session state changes, and a failing validation rejects the call with nothing mutated, persisted, or emitted. Remote sessions record the path as-is.
        *
-       * @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.
+       * @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 any related side-effects (file index, etc.); it does NOT change the process working directory (a session's cwd is per-session, not process-global). For local sessions the runtime validates the target first (an absolute path that exists on disk) and re-bases the permission primary directory; a rejected validation fails the call before anything is mutated, persisted, or emitted. Location-scoped permission rules are then re-keyed to the new directory (best-effort). Remote sessions only record the path.
        */
       setWorkingDirectory: async (params) => connection.sendRequest("session.metadata.setWorkingDirectory", { sessionId, ...params }),
       /**
@@ -1750,9 +2060,20 @@ function createSessionRpc(connection, sessionId) {
       recomputeContextTokens: async (params) => connection.sendRequest("session.metadata.recomputeContextTokens", { sessionId, ...params })
     },
     /** @experimental */
+    contentExclusion: {
+      /**
+       * Checks local file system absolute paths within the session working directory against its content-exclusion policy. Results preserve input order. Unsupported paths/filesystems and unavailable policy evaluation return available false, and callers must treat every requested path as excluded.
+       *
+       * @param params Local file system absolute paths within the session working directory to check against its content-exclusion policy.
+       *
+       * @returns Batch content-exclusion result. Callers must fail closed when policy evaluation is unavailable.
+       */
+      checkPaths: async (params) => connection.sendRequest("session.contentExclusion.checkPaths", { sessionId, ...params })
+    },
+    /** @experimental */
     shell: {
       /**
-       * Starts a shell command and streams output through session notifications.
+       * Starts a shell command and streams output through session notifications. The command runs as the leader of its own process group (POSIX) or in a dedicated job object (Windows), so a forced termination — via "shell.kill", the request timeout, or session disposal — signals that whole group/job rather than only the direct child. Two gaps are worth planning for: a command that exits on its own does not trigger that teardown, and on POSIX a descendant that moves itself into a new session or process group (for example via "setsid") leaves the signalled group, so either can leave a background process running.
        *
        * @param params Shell command to run, with optional working directory and timeout in milliseconds.
        *
@@ -1760,7 +2081,7 @@ function createSessionRpc(connection, sessionId) {
        */
       exec: async (params) => connection.sendRequest("session.shell.exec", { sessionId, ...params }),
       /**
-       * Sends a signal to a shell process previously started via "shell.exec".
+       * Sends a signal to a shell process previously started via "shell.exec". The signal targets the command's whole process group (POSIX) or job object (Windows), so descendants still in that group are signalled too, not just the direct child. On POSIX a descendant that moved itself into a new session or process group (for example via "setsid") is no longer in the signalled group and survives.
        *
        * @param params Identifier of a process previously returned by "shell.exec" and the signal to send.
        *
@@ -1802,6 +2123,28 @@ function createSessionRpc(connection, sessionId) {
        * @returns Number of events that were removed by the truncation.
        */
       truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params }),
+      /**
+       * Lists the user turns that the session can rewind to. Never rejects for a busy session: rewind reads need the session's file-change captures to be settled, so a session that still holds active work answers with `unavailableReason: "session-busy"` and no points, which the caller can retry.
+       *
+       * @returns Rewind points and file-change-tracking availability for the session.
+       */
+      listRewindPoints: async () => connection.sendRequest("session.history.listRewindPoints", { sessionId }),
+      /**
+       * Previews the files that a conversation-and-files rewind would restore.
+       *
+       * @param params Event boundary to preview for conversation-and-files rewind.
+       *
+       * @returns Files and aggregate changes for a prospective rewind.
+       */
+      previewRewind: async (params) => connection.sendRequest("session.history.previewRewind", { sessionId, ...params }),
+      /**
+       * Rewinds the session conversation, optionally restoring files changed by the discarded turns. Not crash-atomic: file restore and conversation truncation are separate stores, applied in that order, so a process crash between them can leave the workspace rewound while the conversation still contains the discarded turns. There is no recovery journal; re-running the same rewind is the recovery path for a crash before truncation lands, since file restore is idempotent (already-restored files are reported as skipped) and truncation is re-derived from the still-retained boundary event. After truncation lands that boundary no longer exists, so the same request is rejected; the only stage that can still be outstanding is snapshot pruning, whose failure leaves orphan snapshots the capture store tolerates. The reverse inconsistency cannot occur, because truncation is never applied before file restore succeeds.
+       *
+       * @param params Boundary and mode for rewinding session history.
+       *
+       * @returns Structured outcome of a rewind request.
+       */
+      rewind: async (params) => connection.sendRequest("session.history.rewind", { sessionId, ...params }),
       /**
        * Cancels any in-progress background compaction on a local session.
        *
@@ -1819,7 +2162,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Markdown summary of the conversation context (empty when not available).
        */
-      summarizeForHandoff: async () => connection.sendRequest("session.history.summarizeForHandoff", { sessionId })
+      summarizeForHandoff: async () => connection.sendRequest("session.history.summarizeForHandoff", { sessionId }),
+      /**
+       * Clears the session's conversation history, keeping only system and developer messages, and seeds the fresh context window with a first user message. Must be called from inside a tool handler: the clear has to drop the results of the tool calls its wipe orphans, and it rejects when no tool call is in flight.
+       *
+       * @param params Parameters for clearing the conversation and seeding the window that replaces it.
+       *
+       * @returns What a successful clear removed. A clear that could not be applied rejects instead of reporting a count.
+       */
+      clearContext: async (params) => connection.sendRequest("session.history.clearContext", { sessionId, ...params })
     },
     /** @experimental */
     queue: {
@@ -1829,6 +2180,60 @@ function createSessionRpc(connection, sessionId) {
        * @returns Snapshot of the session's pending queued items and immediate-steering messages.
        */
       pendingItems: async () => connection.sendRequest("session.queue.pendingItems", { sessionId }),
+      /**
+       * Moves an addressable queued item to a public visible position.
+       *
+       * @param params Parameters for moving a queued item by stable id.
+       *
+       * @returns Result of moving a queued item.
+       */
+      moveItem: async (params) => connection.sendRequest("session.queue.moveItem", { sessionId, ...params }),
+      /**
+       * Inserts a new queued message at a public visible position.
+       *
+       * @param params Parameters for inserting a queued message at a public visible position.
+       *
+       * @returns Result of inserting a queued message.
+       */
+      insertAt: async (params) => connection.sendRequest("session.queue.insertAt", { sessionId, ...params }),
+      /**
+       * Removes an addressable queued item by its stable id.
+       *
+       * @param params Parameters for removing a queued item by stable id.
+       *
+       * @returns Result of removing a queued item.
+       */
+      removeAt: async (params) => connection.sendRequest("session.queue.removeAt", { sessionId, ...params }),
+      /**
+       * Updates the text of an addressable single-message queue item.
+       *
+       * @param params Parameters for editing a single queued message.
+       *
+       * @returns Result of editing a queued message.
+       */
+      updateText: async (params) => connection.sendRequest("session.queue.updateText", { sessionId, ...params }),
+      /**
+       * Duplicates an addressable queued item immediately after its source.
+       *
+       * @param params Parameters for duplicating a queued item.
+       *
+       * @returns Result of duplicating a queued item.
+       */
+      duplicateAt: async (params) => connection.sendRequest("session.queue.duplicateAt", { sessionId, ...params }),
+      /**
+       * Acquires or releases the queued-lane drain pause.
+       *
+       * @param params Parameters for acquiring or releasing the queued-lane drain pause. Acquisition is exclusive and non-idempotent: `paused: true` against an already-paused session fails with `queue_already_paused`. The pause is never released automatically — it is not tied to the caller's lifetime, so a client that exits without sending `paused: false` leaves the lane frozen. Release is unowned: `paused: false` clears the pause for any caller, including one that never acquired it.
+       */
+      setDrainPaused: async (params) => connection.sendRequest("session.queue.setDrainPaused", { sessionId, ...params }),
+      /**
+       * Moves an addressable queued message into the live turn's steering lane.
+       *
+       * @param params Parameters for steering a queued message into a live turn.
+       *
+       * @returns Result of trying to steer a queued message into a live turn.
+       */
+      sendNow: async (params) => connection.sendRequest("session.queue.sendNow", { sessionId, ...params }),
       /**
        * Removes the most recently queued user-facing item (LIFO).
        *
@@ -1843,7 +2248,7 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     eventLog: {
       /**
-       * Reads a batch of session events from a cursor, optionally waiting for new events.
+       * Reads a batch of session events from a cursor, optionally waiting for new events. Supports tail-first reads via `direction: backward`.
        *
        * @param params Cursor, batch size, and optional long-poll/filter parameters for reading session events.
        *
@@ -1883,6 +2288,17 @@ function createSessionRpc(connection, sessionId) {
       getMetrics: async () => connection.sendRequest("session.usage.getMetrics", { sessionId })
     },
     /** @experimental */
+    limitPrediction: {
+      /**
+       * Predicts an AI-credit session limit for the session's resolved model. Returns an unavailable result instead of falling back when the current model is unresolved auto.
+       *
+       * @param params Parameters for predicting an AI-credit session limit. Omitting `modelId` uses the session's currently selected model.
+       *
+       * @returns Prediction result. Available results include prediction details; unavailable results include an explicit reason.
+       */
+      predict: async (params) => connection.sendRequest("session.limitPrediction.predict", { sessionId, ...params })
+    },
+    /** @experimental */
     remote: {
       /**
        * Enables remote session export or steering.
@@ -1943,6 +2359,14 @@ function createSessionRpc(connection, sessionId) {
 }
 function createInternalSessionRpc(connection, sessionId) {
   return {
+    /**
+     * Queues or sends an internal system notification to the session according to its passive policy.
+     *
+     * @param params Internal request for sending a system notification.
+     *
+     * @experimental
+     */
+    sendSystemNotification: async (params) => connection.sendRequest("session.sendSystemNotification", { sessionId, ...params }),
     /** @experimental */
     mcp: {
       /**
@@ -1962,40 +2386,142 @@ function createInternalSessionRpc(connection, sessionId) {
        */
       configureGitHub: async (params) => connection.sendRequest("session.mcp.configureGitHub", { sessionId, ...params }),
       /**
-       * Starts an individual MCP server on the session's host.
+       * 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 Server name and opaque configuration for an individual MCP server start.
+       * @param params Registration parameters for an external MCP client.
        */
-      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
+      registerExternalClient: async (params) => connection.sendRequest("session.mcp.registerExternalClient", { sessionId, ...params }),
       /**
-       * Restarts an individual MCP server on the session's host (stops then starts).
+       * 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 and opaque configuration for an individual MCP server restart.
+       * @param params Server name identifying the external client to remove.
        */
-      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { sessionId, ...params }),
+      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params })
+    },
+    /** @experimental */
+    settings: {
       /**
-       * 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.
+       * Returns a redacted snapshot of session runtime settings, with secrets and raw feature flags excluded. Internal: the runtime settings shape is a runtime-internal surface and is deliberately kept out of the public SDK, because consumers should not depend on the runtime's internal settings layout. It remains callable in-process and is expected to be reworked as the runtime internals are consolidated.
        *
-       * @param params Registration parameters for an external MCP client.
+       * @returns Redacted, serializable view of session runtime settings for SDK boundary consumers. Secrets and raw feature flags are intentionally excluded.
        */
-      registerExternalClient: async (params) => connection.sendRequest("session.mcp.registerExternalClient", { sessionId, ...params }),
+      snapshot: async () => connection.sendRequest("session.settings.snapshot", { sessionId }),
       /**
-       * 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.
+       * Evaluates a named Rust-owned settings predicate without exposing raw feature flags. Internal: the raw feature-flag names and composition are runtime-internal, so this predicate-evaluation helper is kept out of the public SDK surface and is callable in-process only.
        *
-       * @param params Server name identifying the external client to remove.
+       * @param params Named Rust-owned settings predicate to evaluate for this session.
+       *
+       * @returns Result of evaluating a Rust-owned settings predicate.
        */
-      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params }),
-      /** @experimental */
-      oauth: {
-        /**
-         * Responds to a pending MCP OAuth request with an in-process provider. This internal CLI-only API accepts a live OAuthClientProvider instance and cannot be used over the SDK JSON-RPC boundary. Use session.mcp.oauth.handlePendingRequest instead for the public SDK-safe response path.
-         *
-         * @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 })
-      }
+      evaluatePredicate: async (params) => connection.sendRequest("session.settings.evaluatePredicate", { sessionId, ...params })
+    },
+    /** @experimental */
+    queue: {
+      /**
+       * Returns the internal native queue snapshot for in-process session orchestration.
+       *
+       * @returns Internal snapshot of native queue state for local session orchestration.
+       */
+      snapshot: async () => connection.sendRequest("session.queue.snapshot", { sessionId }),
+      /**
+       * Reports whether the local session has native queued work pending.
+       *
+       * @returns Whether the native queue has pending work.
+       */
+      hasPending: async () => connection.sendRequest("session.queue.hasPending", { sessionId }),
+      /**
+       * Begins a native deferred-idle drain when background work has quiesced.
+       *
+       * @param params Inputs for starting a deferred-idle drain.
+       *
+       * @returns Whether a deferred-idle drain should run.
+       */
+      beginDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.beginDeferredIdleDrain", { sessionId, ...params }),
+      /**
+       * Finishes a native deferred-idle drain and reports whether to drain queue work or emit idle.
+       *
+       * @param params Inputs for completing a deferred-idle drain.
+       *
+       * @returns Action selected by the native deferred-idle drain.
+       */
+      finishDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.finishDeferredIdleDrain", { sessionId, ...params }),
+      /**
+       * Marks session.idle as deferred by native background work state.
+       *
+       * @param params Inputs for marking session.idle deferred in native state.
+       */
+      deferSessionIdle: async (params) => connection.sendRequest("session.queue.deferSessionIdle", { sessionId, ...params }),
+      /**
+       * Consumes queued native system notifications matching an internal filter.
+       *
+       * @param params Internal filter for consuming queued system notifications.
+       *
+       * @returns Indicates whether a user-facing pending item was removed.
+       */
+      consumeSystemNotifications: async (params) => connection.sendRequest("session.queue.consumeSystemNotifications", { sessionId, ...params }),
+      /**
+       * Enqueues the internal resume-pending wake item when orphan handling needs a follow-up turn.
+       *
+       * @returns Result of enqueueing the resume-pending wake item.
+       */
+      enqueueResumePending: async () => connection.sendRequest("session.queue.enqueueResumePending", { sessionId }),
+      /**
+       * Drains the native local-session work queue for in-process session orchestration.
+       */
+      process: async () => connection.sendRequest("session.queue.process", { sessionId })
+    },
+    /** @experimental */
+    schedule: {
+      /**
+       * Hydrates the native schedule registry from persisted session events.
+       */
+      hydrate: async () => connection.sendRequest("session.schedule.hydrate", { sessionId }),
+      /**
+       * Reports whether the session has an active self-paced scheduled prompt.
+       *
+       * @returns Whether the session currently has an active self-paced schedule.
+       */
+      hasSelfPaced: async () => connection.sendRequest("session.schedule.hasSelfPaced", { sessionId }),
+      /**
+       * Registers a relative-interval scheduled prompt.
+       *
+       * @param params Register a relative-interval scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      add: async (params) => connection.sendRequest("session.schedule.add", { sessionId, ...params }),
+      /**
+       * Registers a recurring cron scheduled prompt.
+       *
+       * @param params Register a cron scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addCron: async (params) => connection.sendRequest("session.schedule.addCron", { sessionId, ...params }),
+      /**
+       * Registers an absolute-time scheduled prompt.
+       *
+       * @param params Register an absolute-time scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addAt: async (params) => connection.sendRequest("session.schedule.addAt", { sessionId, ...params }),
+      /**
+       * Registers a self-paced scheduled prompt.
+       *
+       * @param params Register a self-paced scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addSelfPaced: async (params) => connection.sendRequest("session.schedule.addSelfPaced", { sessionId, ...params }),
+      /**
+       * Re-arms an active self-paced scheduled prompt.
+       *
+       * @param params Re-arm a self-paced scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      rearmSelfPaced: async (params) => connection.sendRequest("session.schedule.rearmSelfPaced", { sessionId, ...params })
     }
   };
 }
@@ -2005,6 +2531,16 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No providerToken handler registered for session: ${params.sessionId}`);
     return handler.getToken(params);
   });
+  connection.onRequest("factory.execute", async (params) => {
+    const handler = getHandlers(params.sessionId).factory;
+    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
+    return handler.execute(params);
+  });
+  connection.onRequest("factory.abort", async (params) => {
+    const handler = getHandlers(params.sessionId).factory;
+    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
+    return handler.abort(params);
+  });
   connection.onRequest("sessionFs.readFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
@@ -2060,6 +2596,11 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
     return handler.sqliteQuery(params);
   });
+  connection.onRequest("sessionFs.sqliteTransaction", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.sqliteTransaction(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}`);