@github/copilot-language-server 1.552.0 → 1.554.0

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

@@ -28,6 +28,68 @@ __export(rpc_exports, {
 module.exports = __toCommonJS(rpc_exports);
 function createServerRpc(connection) {
   return {
+    /** @experimental */
+    environments: {
+      /**
+       * Lists GitHub Mission Control environments visible to the authenticated identity. Does not require a running host and excludes host relay credentials.
+       *
+       * @param params Optional discovery filters supported by GitHub Mission Control.
+       *
+       * @returns Environments visible to the authenticated caller and matching the supplied filters.
+       */
+      list: async (params) => connection.sendRequest("environments.list", params),
+      /**
+       * Gets safe discovery information for a GitHub Mission Control environment without requiring a running host.
+       *
+       * @param params Identify a Mission Control environment to retrieve.
+       *
+       * @returns Safe discovery information for the requested environment.
+       */
+      get: async (params) => connection.sendRequest("environments.get", params),
+      /**
+       * Deletes a user-managed GitHub Mission Control environment. GitHub-managed environments cannot be deleted. Does not stop a running host, which may register again.
+       *
+       * @param params Identify a user-managed Mission Control environment to delete.
+       *
+       * @returns Acknowledgement that the requested environment was deleted.
+       */
+      delete: async (params) => connection.sendRequest("environments.delete", params)
+    },
+    /** @experimental */
+    host: {
+      /**
+       * Publishes an attached resident session for this listener's lifetime without copying it.
+       *
+       * @param params Publishes a resident session attached to the listener's owning connection.
+       *
+       * @returns The existing runtime identity and its resource on the listener.
+       */
+      publishSession: async (params) => connection.sendRequest("host.publishSession", params),
+      /**
+       * Reads the complete advertised live and dormant session catalog of an existing host owned by this connection. Does not start hosting, subscribe to sessions, or guarantee resumability.
+       *
+       * @param params Reads a running host's catalog or the runtime's saved default catalog.
+       *
+       * @returns The complete live and dormant advertised catalog, without subscribing to sessions.
+       */
+      listSessions: async (params) => connection.sendRequest("host.listSessions", params),
+      /**
+       * Starts a connection-owned AHP host with explicit localServer and/or githubEnvironment transports as a supervised SDK participant.
+       *
+       * @param params Starts a supervised AHP host with at least one explicitly selected transport.
+       *
+       * @returns Listener readiness, returned only after binding and the supervised participant's SDK handshake.
+       */
+      start: async (params) => connection.sendRequest("host.start", params),
+      /**
+       * Stops a listener owned by this SDK connection and joins its cleanup without deleting sessions.
+       *
+       * @param params Stops a connection-owned listener and joins its teardown.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      dispose: async (params) => connection.sendRequest("host.dispose", params)
+    },
     /**
      * Checks server responsiveness and returns protocol information.
      *
@@ -67,6 +129,56 @@ function createServerRpc(connection) {
       getBuiltInCatalog: async () => connection.sendRequest("models.getBuiltInCatalog", {})
     },
     /** @experimental */
+    sandbox: {
+      /**
+       * Reports whether the host running this runtime can run the command sandbox, without starting a session or spawning a sandboxed command.
+       *
+       * @returns Whether the host running this runtime can run the command sandbox. The runtime checks `supported` once per process. A capability answer can change while the process runs, for example after the user installs a missing package.
+       */
+      getHostSupport: async () => connection.sendRequest("sandbox.getHostSupport", {}),
+      /** @experimental */
+      proxyCa: {
+        /**
+         * Reports whether the persistent certificate authority of the sandbox credential proxy exists, whether OS trust includes it, and whether it must be rotated. Changes nothing.
+         *
+         * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+         *
+         * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+         */
+        getStatus: async (params) => connection.sendRequest("sandbox.proxyCa.getStatus", params),
+        /**
+         * Creates the persistent certificate authority of the sandbox credential proxy if none is stored, without changing OS trust, and returns the path of its public certificate. Keeps an existing certificate authority, even one that must be rotated. Fails where OS trust is unsupported. Trust it with sandbox.proxyCa.trust: the CLI trusts only the hosts in the saved user settings, so it refuses a certificate authority that also covers hosts from sandboxConfig.
+         *
+         * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+         *
+         * @returns Result of creating the persistent certificate authority of the sandbox credential proxy.
+         */
+        create: async (params) => connection.sendRequest("sandbox.proxyCa.create", params),
+        /**
+         * Replaces the persistent certificate authority of the sandbox credential proxy with a new one for the current credential hosts. If OS trust included the old one, removes it and trusts the new one, which can show an OS authentication prompt. Running sandboxed tools keep the old certificate authority until they restart.
+         *
+         * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+         *
+         * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+         */
+        rotate: async (params) => connection.sendRequest("sandbox.proxyCa.rotate", params),
+        /**
+         * Adds the persistent certificate authority of the sandbox credential proxy to OS trust, so sandboxed clients that read only OS trust accept the proxy. Call create first. Refuses a certificate authority that is not constrained to the current credential hosts. Can show an OS authentication prompt.
+         *
+         * @param params Identifies the credential hosts that the persistent certificate authority of the sandbox credential proxy must cover. The runtime always adds the hosts from the saved user settings.
+         *
+         * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+         */
+        trust: async (params) => connection.sendRequest("sandbox.proxyCa.trust", params),
+        /**
+         * Removes the persistent certificate authority of the sandbox credential proxy from OS trust. Keeps the stored certificate authority. Can show an OS authentication prompt. Sandboxed clients that read only OS trust then reject the proxy; clients that read the per-process certificate bundle continue to work.
+         *
+         * @returns Status of the persistent certificate authority of the sandbox credential proxy.
+         */
+        remove: async () => connection.sendRequest("sandbox.proxyCa.remove", {})
+      }
+    },
+    /** @experimental */
     tools: {
       /**
        * Lists built-in tools available for a model.
@@ -187,7 +299,74 @@ function createServerRpc(connection) {
        *
        * @returns Outcome of an mcp.planInstall call: either a normalised plan, or one typed refusal. Nothing is written in either case.
        */
-      planInstall: async (params) => connection.sendRequest("mcp.planInstall", params)
+      planInstall: async (params) => connection.sendRequest("mcp.planInstall", params),
+      /**
+       * Consumes a bound catalogue plan and retains one exact fully resolved personal remote MCP operation requiring no supplied values or configured secrets. Returns its runtime operation ID and original expiry before any confirmation, activation, writer initialisation or installation effect. Register the original connection, operation and selected-session binding before calling applyInstall. Missing lower owned admission is unavailable, never a raw-config fallback.
+       *
+       * @param params Side-effect-free preparation of one original bound remote MCP choice.
+       *
+       * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+       */
+      prepareInstall: async (params) => connection.sendRequest("mcp.prepareInstall", params),
+      /**
+       * Consumes a retained prepared MCP operation once, revalidates its original authority, requests explicit human consent through installations.confirm on the original connection, then revalidates source and applies the sealed transaction. An uncertain result requires original-operation inspection or recovery, never replay.
+       *
+       * @param params Applies exactly one previously prepared operation on its original connection.
+       *
+       * @returns An installation result together with the exact honoured contract, or a negotiation refusal.
+       */
+      applyInstall: async (params) => connection.sendRequest("mcp.applyInstall", params),
+      /**
+       * Prepares a read-only removal plan for an exact owned receipt under the selected existing session. Returns the original operation ID before confirmation; neither planning nor abandonment changes configuration or shared OAuth credentials.
+       *
+       * @param params Read-only preparation of one owned removal under fresh selected-session authority.
+       *
+       * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+       */
+      planUninstall: async (params) => connection.sendRequest("mcp.planUninstall", params),
+      /**
+       * Consumes the original owned-removal plan once and requests fresh exact human confirmation on its original connection. Drift is refused; unrelated manual configuration and shared OAuth credentials are preserved.
+       *
+       * @param params One-use application of the exact retained removal plan.
+       *
+       * @returns An installation result together with the exact honoured contract, or a negotiation refusal.
+       */
+      applyUninstall: async (params) => connection.sendRequest("mcp.applyUninstall", params),
+      /** @experimental */
+      installations: {
+        /**
+         * Reads receipt-owned MCP inventory for the selected account and host without activating servers or reconstructing missing ownership. Configuration ownership does not prove session-specific usability.
+         *
+         * @param params New-work inventory or recovery request under an explicitly selected existing session.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        list: async (params) => connection.sendRequest("mcp.installations.list", params),
+        /**
+         * Reconciles already-confirmed durable MCP transactions, then inspects owned inventory. Does not replay apply or reconstruct deleted ownership metadata; unresolved or unsafe evidence remains an explicit refusal.
+         *
+         * @param params New-work inventory or recovery request under an explicitly selected existing session.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        recover: async (params) => connection.sendRequest("mcp.installations.recover", params),
+        /**
+         * Inspects a known operation only on its original connection. Remains available after account or selected-session loss; does not acquire new authority or rebind an operation.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        status: async (params) => connection.sendRequest("mcp.installations.status", params),
+        /**
+         * Requests cancellation of a known operation on its original connection, including before apply or confirmation. Already-started effects retain their transaction lease and report an honest terminal or recovery outcome.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        cancel: async (params) => connection.sendRequest("mcp.installations.cancel", params)
+      }
     },
     /** @experimental */
     extensions: {
@@ -210,6 +389,115 @@ function createServerRpc(connection) {
        */
       disable: async (params) => connection.sendRequest("extensions.disable", params)
     },
+    /** @experimental */
+    skills: {
+      /**
+       * Plans installation of a verified Agent Finder Skill candidate without writing files. The returned review is safe to present to a user and installing always leaves the Skill disabled until separately enabled.
+       *
+       * @param params Side-effect-free planning of one verified Agent Finder Skill candidate.
+       *
+       * @returns Skill installation management result with the honoured contract, or a typed refusal.
+       */
+      planInstall: async (params) => connection.sendRequest("skills.planInstall", params),
+      /**
+       * Consumes one verified Skill installation plan, requests explicit human consent through installations.confirm on the original connection, then revalidates and installs the Skill disabled.
+       *
+       * @param params Applies exactly one retained verified Skill installation plan.
+       *
+       * @returns Skill installation result with the honoured contract, or a typed request/negotiation refusal.
+       */
+      applyInstall: async (params) => connection.sendRequest("skills.applyInstall", params),
+      /** @experimental */
+      installations: {
+        /**
+         * Lists owned verified Agent Finder Skill installations for the selected existing session. Listing is never gated by the Skill-install feature flag.
+         *
+         * @param params Inventory request under an explicitly selected existing session.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        list: async (params) => connection.sendRequest("skills.installations.list", params),
+        /**
+         * Reconciles interrupted owned Skill installation work for the selected existing session, then inspects owned inventory. Recovery is never gated by the Skill-install feature flag.
+         *
+         * @param params Inventory request under an explicitly selected existing session.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        recover: async (params) => connection.sendRequest("skills.installations.recover", params),
+        /**
+         * Inspects a known Skill installation operation on its original runtime connection. Status is never gated by the Skill-install feature flag.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        status: async (params) => connection.sendRequest("skills.installations.status", params),
+        /**
+         * Requests cancellation of a known Skill installation operation before commit. Already-started durable work requires recovery instead of silent replay.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        cancel: async (params) => connection.sendRequest("skills.installations.cancel", params),
+        /**
+         * Atomically persists enablement for one owned Agent Finder Skill and reconciles the selected bound session. Enablement is installation-scoped by receipt identity and is never gated by the Skill-install feature flag.
+         *
+         * @param params Persisted enablement update for one owned Skill installation.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        setEnabled: async (params) => connection.sendRequest("skills.installations.setEnabled", params)
+      },
+      /**
+       * Prepares a read-only removal plan for an owned verified Agent Finder Skill installation. Uninstall planning is never gated by the Skill-install feature flag.
+       *
+       * @param params Read-only preparation of one owned Skill removal under fresh selected-session authority.
+       *
+       * @returns Skill installation management result with the honoured contract, or a typed refusal.
+       */
+      planUninstall: async (params) => connection.sendRequest("skills.planUninstall", params),
+      /**
+       * Consumes an owned Skill removal plan, requests explicit human consent through installations.confirm, refuses drift, and removes the exact owned files through quarantine.
+       *
+       * @param params One-use application of the exact retained Skill removal plan.
+       *
+       * @returns Skill installation result with the honoured contract, or a typed request/negotiation refusal.
+       */
+      applyUninstall: async (params) => connection.sendRequest("skills.applyUninstall", params),
+      /** @experimental */
+      config: {
+        /**
+         * Replaces the global list of disabled skills.
+         *
+         * @param params Skill names to mark as disabled in global configuration, replacing any previous list.
+         */
+        setDisabledSkills: async (params) => connection.sendRequest("skills.config.setDisabledSkills", params),
+        /**
+         * Atomically adds or removes one skill from the disabled list.
+         *
+         * @param params Adds or removes a single skill from the global disabled list, leaving every other entry untouched.
+         */
+        setSkillDisabled: async (params) => connection.sendRequest("skills.config.setSkillDisabled", params)
+      },
+      /**
+       * Discovers skills across global and project sources.
+       *
+       * @param params Optional project paths and additional skill directories to include in discovery.
+       *
+       * @returns Skills discovered across global and project sources.
+       */
+      discover: async (params) => connection.sendRequest("skills.discover", params),
+      /**
+       * 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.
+       */
+      getDiscoveryPaths: async (params) => connection.sendRequest("skills.getDiscoveryPaths", params)
+    },
     /**
      * Registers the calling SDK client as the per-entrypoint extension launch provider. Call before creating any sessions. When omitted, the runtime uses its built-in extension launcher.
      *
@@ -225,7 +513,15 @@ function createServerRpc(connection) {
        *
        * @returns Outcome of a catalog.search call: either bounded inert candidates, or one typed refusal. Never a partial success.
        */
-      search: async (params) => connection.sendRequest("catalog.search", params)
+      search: async (params) => connection.sendRequest("catalog.search", params),
+      /**
+       * Terminates one retained catalog selection group. A selected outcome returns the native host a fresh single-use candidate handle plus the original searchId for a later explicit mcp.planInstall call; non-selected outcomes release the group without producing a planning input. Candidate state, cards, URLs, credentials and private identifiers remain inside the runtime. The model-facing catalog_select tool projects the result separately and never exposes the candidate handle or searchId.
+       *
+       * @param params Terminates one retained catalog selection group through an opaque reference previously returned by the model-safe search projection.
+       *
+       * @returns Typed outcome of catalog.select. Only the selected host result carries a fresh candidate handle; the model-facing projection removes both that handle and searchId.
+       */
+      select: async (params) => connection.sendRequest("catalog.select", params)
     },
     /** @experimental */
     plugins: {
@@ -327,40 +623,6 @@ function createServerRpc(connection) {
       }
     },
     /** @experimental */
-    skills: {
-      /** @experimental */
-      config: {
-        /**
-         * Replaces the global list of disabled skills.
-         *
-         * @param params Skill names to mark as disabled in global configuration, replacing any previous list.
-         */
-        setDisabledSkills: async (params) => connection.sendRequest("skills.config.setDisabledSkills", params),
-        /**
-         * Atomically adds or removes one skill from the disabled list.
-         *
-         * @param params Adds or removes a single skill from the global disabled list, leaving every other entry untouched.
-         */
-        setSkillDisabled: async (params) => connection.sendRequest("skills.config.setSkillDisabled", params)
-      },
-      /**
-       * Discovers skills across global and project sources.
-       *
-       * @param params Optional project paths and additional skill directories to include in discovery.
-       *
-       * @returns Skills discovered across global and project sources.
-       */
-      discover: async (params) => connection.sendRequest("skills.discover", params),
-      /**
-       * 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.
-       */
-      getDiscoveryPaths: async (params) => connection.sendRequest("skills.getDiscoveryPaths", params)
-    },
-    /** @experimental */
     agents: {
       /**
        * Discovers custom agents across user, project, plugin, and remote sources.
@@ -412,21 +674,15 @@ function createServerRpc(connection) {
       /** @experimental */
       settings: {
         /**
-         * Drops this runtime process's in-memory user settings cache so the next settings read observes disk.
-         */
-        reload: async () => connection.sendRequest("user.settings.reload", {}),
-        /**
-         * Lists every known user setting (settings.json overlaid with the legacy config.json, config.json wins), each with its effective value, its default, and whether it is at the default — so settings the user has never set still appear with their default value. Does not include repository- or enterprise-managed overrides that the runtime layers on top at session time.
+         * Lists every known user setting from settings.json, each with its effective value, its default, and whether it is at the default — so settings the user has never set still appear with their default value. Does not include repository- or enterprise-managed overrides that the runtime layers on top at session time.
          *
-         * @returns Per-key metadata for every known user setting (settings.json overlaid with the legacy config.json, config.json wins), including settings left at their default. Excludes repository- and enterprise-managed overrides.
+         * @returns Per-key metadata for every known user setting in settings.json, including settings left at their default. Excludes repository- and enterprise-managed overrides.
          */
         get: async () => connection.sendRequest("user.settings.get", {}),
         /**
-         * Writes one or more user settings to settings.json, replacing each provided top-level key. A key whose value is null is removed. Returns the keys whose new value is shadowed by a legacy config.json entry (config.json wins on read), which the runtime leaves in place — such writes do not take effect until the legacy value is removed.
+         * Writes one or more user settings to settings.json, replacing each provided top-level key. A key whose value is null is removed.
          *
          * @param params Partial user settings to write to settings.json. Each top-level key is written individually, replacing the existing value; a key whose value is null is removed.
-         *
-         * @returns Outcome of writing user settings.
          */
         set: async (params) => connection.sendRequest("user.settings.set", params)
       }
@@ -434,15 +690,56 @@ function createServerRpc(connection) {
     /** @experimental */
     managedSettings: {
       /**
-       * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session.
+       * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session. `managedSettings.resolve` returns the same device settings together with the account's server policy.
        *
        * @returns Validated device-managed settings discovered before a session exists.
        */
       read: async () => connection.sendRequest("managedSettings.read", {}),
       /**
-       * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
+       * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should call `managedSettings.resolve` or start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
        */
-      clearCache: async () => connection.sendRequest("managedSettings.clearCache", {})
+      clearCache: async () => connection.sendRequest("managedSettings.clearCache", {}),
+      /**
+       * Resolves the effective enterprise managed settings without a session, from the device channel and, when an account is available, the account's server policy through the same per-account cache sessions use. A cached server policy less than an hour old is used without a fetch; otherwise the policy is fetched, and when the fetch fails a cached policy up to 24 hours old is used instead, unless `forceRemoteSettingsRefresh` requires a live fetch. With no account requested or signed in, it reports device policy only; signing out removes the account's cached policy. It can fetch server policy over the network when the cache is stale, so call it off latency-critical paths such as startup rather than before listing models. The policy helper is not run. `layers` lists each channel's document before merging, and `values` and `meta` carry typed effective values and their lock state for the keys typed so far.
+       *
+       * @param params Optional opaque account selection or GitHub token whose managed settings are resolved.
+       *
+       * @returns Effective enterprise managed settings for an account, resolved without a session.
+       */
+      resolve: async (params) => connection.sendRequest("managedSettings.resolve", params),
+      /** @experimental */
+      permissions: {
+        /**
+         * Pure, sessionless evaluation of operations against a supplied permissionsContext. Performs no policy discovery, I/O, prompting, navigation, permission grants, or sandbox changes. Obtain the context from managedSettings.resolve or session.managedSettings.get, or reuse an in-memory context. Results preserve input order and duplicates. Consumers must block deny, obtain approval for ask, and use their normal permission flow for unmanaged. Unknown policy returns failClosed with every operation denied. This is not a substitute for user permissions or other security controls.
+         *
+         * @param params Managed policy context and ordered operations for pure, sessionless evaluation.
+         *
+         * @returns Ordered managed permission verdicts and the supplied policy's fail-closed posture.
+         */
+        evaluate: async (params) => connection.sendRequest("managedSettings.permissions.evaluate", params)
+      },
+      /**
+       * Returns the managed-settings authoring JSON schema with descriptive `x-composition` annotations aligned with the shared settings-engine vocabulary. These annotations are not a complete runtime composition contract: model, effortLevel, and contextTier remain coupled. Use `managedSettings.compose` for the runtime's effective result. Performs no I/O.
+       *
+       * @returns The authoring JSON schema for managed settings recognized by this runtime.
+       */
+      schema: async () => connection.sendRequest("managedSettings.schema", {}),
+      /**
+       * Validates a candidate managed-settings document the way the runtime validates delivered policy, without applying it. Reports errors that would reject the document, warnings for content the runtime ignores, and the canonical document it would apply. Document text nested more than 64 levels deep is rejected. Performs no I/O.
+       *
+       * @param params A candidate managed-settings document to validate without applying it.
+       *
+       * @returns Result of validating a managed-settings document.
+       */
+      validate: async (params) => connection.sendRequest("managedSettings.validate", params),
+      /**
+       * Merges candidate managed-settings documents for the device, server, and policy-helper channels into the effective settings the runtime would enforce on this host, using the same precedence and composition rules as live resolution, without applying them. Like live resolution, a server's advisory sandbox force-enable is declined on a host that cannot run the sandbox. Does not fetch policy or read policy files, but may perform blocking OS or subprocess probes for sandbox support. Preview documents are limited to 1 MiB and 64 levels of nesting.
+       *
+       * @param params Candidate managed-settings documents to merge without applying them.
+       *
+       * @returns The effective managed settings the runtime would enforce for the given documents, in the same shape `managedSettings.resolve` returns.
+       */
+      compose: async (params) => connection.sendRequest("managedSettings.compose", params)
     },
     /** @experimental */
     runtime: {
@@ -456,7 +753,7 @@ function createServerRpc(connection) {
       /**
        * Registers an SDK client as the session filesystem provider.
        *
-       * @param params Initial working directory, session-state path layout, and path conventions used to register the calling SDK client as the session filesystem provider.
+       * @param params Initial working directory, session-state path layout, and path conventions used to register the calling SDK client as the session filesystem provider. A registered provider is authoritative for path interpretation and filesystem facts used by workspace permission validation. Paths are interpreted lexically; home-relative paths (`~` and `~/...`) and Windows drive-relative paths such as `C:foo` are unsupported. Until provider-side canonicalization is supported, providers must not expose symlinks inside allowed roots that escape those roots.
        *
        * @returns Indicates whether the calling client was registered as the session filesystem provider.
        */
@@ -696,11 +993,81 @@ function createServerRpc(connection) {
        * @returns Outcome of an agentRegistry.spawn call.
        */
       spawn: async (params) => connection.sendRequest("agentRegistry.spawn", params)
+    },
+    /** @experimental */
+    connectors: {
+      /**
+       * Returns feature availability.
+       *
+       * @returns Feature availability.
+       */
+      getCapabilities: async () => connection.sendRequest("connectors.getCapabilities", {}),
+      /**
+       * Returns eligible accounts.
+       *
+       * @returns Eligible accounts.
+       */
+      getAccounts: async () => connection.sendRequest("connectors.getAccounts", {}),
+      /**
+       * Lists entries for the selected account.
+       *
+       * @param params Selected account.
+       *
+       * @returns Entries for the selected account.
+       */
+      list: async (params) => connection.sendRequest("connectors.list", params),
+      /**
+       * Refreshes entries for the selected account.
+       *
+       * @param params Selected account.
+       *
+       * @returns Entries for the selected account.
+       */
+      refresh: async (params) => connection.sendRequest("connectors.refresh", params)
     }
   };
 }
 function createInternalServerRpc(connection) {
   return {
+    /** @experimental */
+    host: {
+      /**
+       * Requests app-owned materialization over the owning SDK participant.
+       *
+       * @param params One application-owned session handoff, requested by the supervised hosting participant.
+       *
+       * @returns The resident session the application has materialized on its own connection.
+       */
+      createSession: async (params) => connection.sendRequest("host.createSession", params),
+      /**
+       * Releases app ownership retention after AHP detaches.
+       *
+       * @param params Ends one participation, not the application's session lifetime.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      releaseSession: async (params) => connection.sendRequest("host.releaseSession", params),
+      /**
+       * Resolves current authenticated credentials and remote-control policy only for the runtime-owned Mission Control hosting participant.
+       *
+       * @returns Private credentials delivered only to a runtime-owned Mission Control hosting participant.
+       */
+      getEnvironmentCredentials: async () => connection.sendRequest("host.getEnvironmentCredentials", {}),
+      /**
+       * Returns listener settings only to the supervised hosting participant over its SDK connection.
+       *
+       * @returns Normalized listener settings delivered only to the supervised hosting participant.
+       */
+      getConfiguration: async () => connection.sendRequest("host.getConfiguration", {}),
+      /**
+       * Reports a supervised hosting participant's bound AHP endpoint after its SDK handshake.
+       *
+       * @param params Readiness reported by the supervised hosting participant on its own SDK connection.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      ready: async (params) => connection.sendRequest("host.ready", params)
+    },
     /**
      * 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.
      *
@@ -712,6 +1079,169 @@ function createInternalServerRpc(connection) {
      */
     connect: async (params) => connection.sendRequest("connect", params),
     /** @experimental */
+    mcp: {
+      /** @experimental */
+      registry: {
+        /**
+         * Allocates an ID for one cancellable MCP registry search. The ID exists before the search starts, so callers can cancel before it starts. The networking stack supplies the cancellation namespace. The runtime retains at most 1,024 unused IDs. At capacity, another allocation can reclaim an unused ID. Active searches retain their IDs until they finish.
+         *
+         * @returns Request id naming a cancellable registry search.
+         */
+        allocateRequestId: async () => connection.sendRequest("mcp.registry.allocateRequestId", {}),
+        /**
+         * Searches the MCP registry the supplied credential may read, resolving the registry endpoint from policy first. Hosts usually send credential-free `AuthIdentity`; a `token` identity can be resolved only when it embeds a token, while `env` and `gh-cli` identities can use a token embedded in the request first. The runtime follows registry pages, keeps the newest entry per server name, cuts the list to `limit`, and sorts an empty-query result by GitHub stars. Each server object is carried opaquely.
+         *
+         * @param params Registry search terms, the credential to search under, and the request id that makes the search cancellable.
+         *
+         * @returns Servers selected from the registry response.
+         */
+        search: async (params) => connection.sendRequest("mcp.registry.search", params),
+        /**
+         * Abandons the registry search that uses the given request ID. It acts only on IDs from `mcp.registry.allocateRequestId`, so it never cancels another component's request. Answers `canceled: true` when it stops a running search. Answers `canceled: false` for unknown or reclaimed IDs, completed or canceled searches, and unused reservations. It releases an unused reservation, so a later search with that ID is refused.
+         *
+         * @param params Registry search to abandon.
+         *
+         * @returns Whether the cancel reached a live search.
+         */
+        cancel: async (params) => connection.sendRequest("mcp.registry.cancel", params)
+      },
+      /**
+       * Reports whether the gh-replaceable GitHub MCP tools may be clipped for a session, which a host feeds back as the `excludeGhReplaceableTools` build option. The tools are redundant only when the session can reach a shell *and* the host has the `gh` that would replace them, so both halves are decided here. The shell half runs the platform shell tool through the runtime's own tool-filter matcher, so entry forms like `builtin:bash` and `builtin:*` behave exactly as they do when a session builds its tool catalog. The host half probes for `gh`, and is skipped entirely when the filters already rule the shell out. Host presence alone is not enough: a session restricted to, say, `view` would otherwise lose the built-in issue-read fallback while having no shell to replace it with. The answer describes the host the runtime runs on, so it is never forwarded to a remote engine.
+       *
+       * @param params The session tool filters that decide whether the session still has a shell to run `gh` with.
+       *
+       * @returns Whether the gh-replaceable GitHub MCP tools may be clipped for the session described by the request.
+       */
+      shouldExcludeGitHubTools: async (params) => connection.sendRequest("mcp.shouldExcludeGitHubTools", params)
+    },
+    /** @experimental */
+    agents: {
+      /**
+       * Lists the agents this runtime ships, by name. A consumer separating shipped agents from ones the user or a plugin authored should compare against these names rather than against `AgentInfo.source`: an authored agent may carry the `builtin` source while not being one of these, and the runtime treats the two as separate questions. `disableableNames` is the subset a user may turn off, which a client needs to decide whether to offer a toggle. `yamlBasedNames` is the subset backed by a shipped YAML definition, which a client needs before asking the runtime to load one.
+       *
+       * @returns The agents this runtime ships, named so a consumer can tell them apart from authored ones.
+       */
+      getBuiltins: async () => connection.sendRequest("agents.getBuiltins", {}),
+      /**
+       * Lists the shipped agents a client should offer right now, filtered by the feature flags it passes. `getBuiltins` names every agent the runtime knows about; some of those are gated, so a client rendering a picker wants this narrower list together with the description to show beside each name.
+       *
+       * @param params The feature flags to evaluate shipped agents against.
+       *
+       * @returns The shipped agents available under the requested flags.
+       */
+      getAvailableBuiltins: async (params) => connection.sendRequest("agents.getAvailableBuiltins", params),
+      /**
+       * Loads one shipped agent's YAML definition, for a client that needs what the agent declares rather than only its name. `getBuiltins` reports which names have a definition to load: a name outside its `yamlBasedNames` is special-cased in code and has none. The definition crosses as its own JSON rather than as contract-typed fields, because the runtime parses it with the agent schema's tolerant shape and re-typing it here would drop the keys that shape accepts and this one does not. The projected `__nativeCustomAgent` view the runtime derives is included, so a caller reading the declared model and a caller rendering the agent see the same definition.
+       *
+       * @param params The shipped agent whose definition to load.
+       *
+       * @returns One shipped agent's definition.
+       */
+      getBuiltinDefinition: async (params) => connection.sendRequest("agents.getBuiltinDefinition", params),
+      /**
+       * Projects one shipped agent the way a picker lists it, reading only the metadata at the head of the definition file and stopping before the prompt body. `getBuiltinDefinition` answers the whole definition instead, so a client listing every shipped agent should prefer this one: the cost of a listing grows with the number of agents, and the prompt body is the part a listing never shows. The two also differ in shape. This returns the projected custom agent on its own, whereas `getBuiltinDefinition` returns the authored definition with that projection nested under `__nativeCustomAgent`.
+       *
+       * @param params The shipped agent whose listing entry to load.
+       *
+       * @returns One shipped agent, projected for a listing.
+       */
+      getBuiltinListingDefinition: async (params) => connection.sendRequest("agents.getBuiltinListingDefinition", params),
+      /**
+       * Resolves the model a custom agent asks for against the models actually available, and answers both the model to switch to and the warning a user should see when the agent's preference cannot be met. A custom agent may name several acceptable models in preference order, so the decision is a match rather than a lookup, and an agent whose preference is unavailable is a normal outcome that produces a warning rather than an error. A host must call this rather than pick the first available name itself, because the preference order and the wording of the warning are what keep one installation's agent selection the same as another's.
+       *
+       * @param params The models a custom agent asks for, and the models actually available.
+       *
+       * @returns The model to switch to, and the warning to show when the agent's preference could not be met.
+       */
+      customAgentInitialModelDecision: async (params) => connection.sendRequest("agents.customAgentInitialModelDecision", params)
+    },
+    /** @experimental */
+    globalState: {
+      /**
+       * Reads the host's machine-wide state: which plugins are installed and the one-off flags and timestamps that record what the user has already been shown or migrated. This is the state that outlives a single session and a single workspace, so a host reads it to decide whether to run a first-launch step, offer an onboarding prompt, or skip one it has already completed. The stored credentials are deliberately not part of this result; a caller that needs an authenticated identity asks the account methods for it instead. Reading is non-destructive and every field is optional, because a fresh install has recorded nothing yet.
+       *
+       * @returns The host's machine-wide state. Every field is optional because a fresh install has recorded nothing yet, so a reader must treat an absent field as `not yet`, never as a negative answer. Stored credentials are deliberately absent from this shape.
+       */
+      load: async () => connection.sendRequest("globalState.load", {}),
+      /**
+       * Reads the host's machine-wide state exactly as `globalState.load` does, but from a caller-supplied configuration directory instead of the one the server resolved for itself. Use this when a consumer scopes a session to its own Copilot home — the SDK's per-session `configDir` override — so the state read matches the directory that session actually uses. An absent or empty `configDir` resolves the server's own home, making this identical to `globalState.load`. The stored credentials are omitted here for the same reason they are omitted from `globalState.load`: a caller that needs an authenticated identity asks the account methods instead, so pointing this at another directory cannot be used to read the credentials kept in it.
+       *
+       * @param params Selects the configuration directory whose machine-wide state to read.
+       *
+       * @returns The host's machine-wide state. Every field is optional because a fresh install has recorded nothing yet, so a reader must treat an absent field as `not yet`, never as a negative answer. Stored credentials are deliberately absent from this shape.
+       */
+      loadForConfigDir: async (params) => connection.sendRequest("globalState.loadForConfigDir", params),
+      /**
+       * Records one top-level key in the host's machine-wide state, the counterpart to `globalState.load`. A host calls this to remember that it has shown an onboarding step, asked a one-off question, or completed a migration, so the next run can skip it. Only the named key is replaced and the rest of the document is preserved, which lets two writers record different flags without overwriting each other; passing no value removes the key instead. Only the keys a host records itself are writable: `appTipShown`, `askedSetupTerminals`, `autoFeedbackLastPromptedAt`, `firstLaunchAt`, `recentModelIds`, `sandboxCredentialProxyCaDeclined` and `sandboxOnboardingShown`. Every other key is refused, including `installedPlugins`, the stored credentials, `trustedFolders`, the staff flags and the signed-in accounts. Plugin enablement must use the plugin APIs, which apply repository and managed-policy checks.
+       *
+       * @param params A single top-level key to record in the host's machine-wide state. The write replaces only that key and leaves the rest of the document untouched, so two writers recording different one-off flags do not overwrite each other. The stored credential keys cannot be written through this method.
+       */
+      writeKey: async (params) => connection.sendRequest("globalState.writeKey", params)
+    },
+    /** @experimental */
+    gitHubRepository: {
+      /**
+       * Resolves the GitHub repository that owns a working-tree path by reading the selected git remote configured for it, preferring `origin`. Returns a null `repository` when the path is inside a git working tree but that selected remote does not resolve to a GitHub host. Fails when the path is not inside a git working tree at all, so a caller can tell 'not a repository' apart from 'a repository with no GitHub remote'.
+       *
+       * @param params Working-tree path whose owning GitHub repository should be resolved.
+       *
+       * @returns The GitHub repository that owns the requested path, when the selected remote (`origin`, else the first) is on a GitHub host.
+       */
+      atPath: async (params) => connection.sendRequest("gitHubRepository.atPath", params)
+    },
+    /** @experimental */
+    gitHubOwners: {
+      /**
+       * Registers a cancellable owner listing and returns its request id. Separate from `gitHubOwners.list` so the id exists before the listing starts: a caller that abandons the listing the moment it begins would otherwise have nothing to name in `gitHubOwners.cancel`. The id serves one listing only. Long-abandoned unused ids can be released by later allocations.
+       *
+       * @returns A freshly registered request id. Registering it before the listing starts is what lets a cancel that races the request still find the owner listing slot. The id serves one listing only. Long-abandoned unused ids can be released by later allocations.
+       */
+      nextRequestId: async () => connection.sendRequest("gitHubOwners.nextRequestId", {}),
+      /**
+       * Lists the logins the authenticated user may act as — their own account first, then the organizations they belong to — by asking the GitHub API under the supplied credential. No credential travels in the request: `authInfo` selects one the runtime already holds, and the runtime resolves the token and the GitHub host from it. A failure the caller should render arrives as `message`; one it should raise arrives as `throwError`.
+       *
+       * @param params Credential to list owners under, and the request id that makes the listing cancellable.
+       *
+       * @returns Outcome of an owner listing. Exactly one of `owners` and `message` is present, except that `throwError` reports a failure the caller is expected to raise rather than render.
+       */
+      list: async (params) => connection.sendRequest("gitHubOwners.list", params),
+      /**
+       * Abandons an owner listing started with the given request id. Answers `canceled: true` while a listing with that id is running. Answers `canceled: false` when the id was never registered, was registered but not used, was released after being abandoned, or its listing has ended. Canceling an unused id releases it, and a later `list` with that id is refused. The cancel acts only on owner listings and never reaches another request of the host.
+       *
+       * @param params The owner listing to abandon.
+       *
+       * @returns Whether the id named a running owner listing.
+       */
+      cancel: async (params) => connection.sendRequest("gitHubOwners.cancel", params)
+    },
+    /** @experimental */
+    git: {
+      /**
+       * Reads the remote that the branch checked out in a working tree tracks, as `branch.<name>.remote` configures it. Reports `origin` rather than failing whenever there is no tracking configuration to read — on a detached HEAD, on a branch with no upstream, or when git itself fails — because a caller asking which remote to talk to needs an answer it can act on, not an error. Marked internal because it exists to carry a CLI call site off the napi boundary onto the SDK contract; it is migration plumbing, not a surface consumers are meant to depend on.
+       *
+       * @param params Working-tree path a git query applies to.
+       *
+       * @returns The remote the checked-out branch tracks.
+       */
+      currentBranchRemote: async (params) => connection.sendRequest("git.currentBranchRemote", params),
+      /**
+       * Collects the repository context of a working directory in one call: working tree root, repository identifier and host, current branch, and the HEAD and base commits. Every repository field is omitted when the path is not inside a git working tree, and the requested path is echoed back as `cwd`. The answer is the same `SessionWorkingDirectoryContext` that `session.metadata.recordContextChange` accepts, so a caller polling for a context change can forward the result unchanged. Marked internal because it exists to carry a CLI call site off the napi boundary onto the SDK contract; it is migration plumbing, not a surface consumers are meant to depend on. It can become public once an SDK consumer needs to derive session context from a directory itself.
+       *
+       * @param params Working-tree path a git query applies to.
+       *
+       * @returns Updated working directory and git context. Emitted as the new payload of `session.context_changed`.
+       */
+      workingDirectoryContext: async (params) => connection.sendRequest("git.workingDirectoryContext", params),
+      /**
+       * Lists the GitHub repositories a working tree's remotes point at, one entry per distinct repository, so a caller can resolve a base and head repository without parsing remote URLs itself. When several remotes name the same repository, only the first is listed, and the entry keeps that remote name. Remotes pointing at no GitHub host are left out, so an empty list means the tree reaches GitHub through no remote. Failing to read the remotes is reported as an error rather than as an empty list, because the two mean different things to a caller. Marked internal because it exists to carry a CLI call site off the napi boundary onto the SDK contract; it is migration plumbing, not a surface consumers are meant to depend on.
+       *
+       * @param params Git working tree whose GitHub remotes should be listed.
+       *
+       * @returns The GitHub repositories a working tree's remotes point at.
+       */
+      reposFromRemotes: async (params) => connection.sendRequest("git.reposFromRemotes", params)
+    },
+    /** @experimental */
     sessions: {
       /**
        * Reads lightweight persisted metadata for one local session without opening it.
@@ -751,6 +1281,30 @@ function createInternalServerRpc(connection) {
        * @param params Session ID to delete from disk.
        */
       delete: async (params) => connection.sendRequest("sessions.delete", params),
+      /**
+       * Creates the workspace record for a session that has not been opened yet. A host that hands a session off to another application — writing the record and then launching that application against the session ID — needs the record on disk before any session exists to carry it, which the session-scoped workspace methods cannot do. Replaces any existing record and resets the checkpoint index. When writing to the local filesystem, a stored `fork_count` survives on disk. Returns the record it built, so a surviving stored `fork_count` can differ from the answer.
+       *
+       * @param params Identity, state location and starting context for a workspace record.
+       *
+       * @returns The workspace record that was written.
+       */
+      createWorkspace: async (params) => connection.sendRequest("sessions.createWorkspace", params),
+      /**
+       * Reads a session's workspace record straight from disk, without opening the session. Resuming by session ID has to know where the session lives before it can connect, so the lookup cannot come from the session-scoped workspace methods, which resolve their location from a live session's context. Returns no record when the file is absent.
+       *
+       * @param params Where the session's state lives, as a root directory and the session ID under it.
+       *
+       * @returns The workspace record on disk, omitted when the session has none.
+       */
+      loadWorkspace: async (params) => connection.sendRequest("sessions.loadWorkspace", params),
+      /**
+       * Merges fields into a session's workspace record on disk, creating the record when it is absent. The counterpart to `sessions.loadWorkspace`, for the same before-the-session-exists case. It preserves stored workspace-schema fields the request does not supply, does not preserve stored keys outside the workspace schema, and never replaces a stored `fork_count`.
+       *
+       * @param params Where the session's state lives, plus workspace-schema fields to merge into its workspace record. Stored keys outside the schema are not preserved, and a stored `fork_count` is never replaced.
+       *
+       * @returns The merge completed. The record carries the supplied workspace-schema fields, but a stored `fork_count` stays.
+       */
+      updateWorkspaceFields: async (params) => connection.sendRequest("sessions.updateWorkspaceFields", 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.
        *
@@ -770,6 +1324,50 @@ function createInternalServerRpc(connection) {
 }
 function createSessionRpc(connection, sessionId) {
   return {
+    /** @experimental */
+    providers: {
+      /**
+       * Returns adapter definitions and supported operations in this session's effective provider catalog, without running discovery. Does not list provider instances or select inference models.
+       *
+       * @returns Normalized model-provider adapter definitions available to the session, not discovered instances.
+       */
+      getCatalog: async () => connection.sendRequest("session.providers.getCatalog", { sessionId }),
+      /**
+       * Discovers reachable instances using an adapter from this session's effective provider catalog and provider-specific discovery input.
+       *
+       * @param params Provider discovery parameters.
+       *
+       * @returns Provider instances found by a discovery operation.
+       */
+      discover: async (params) => connection.sendRequest("session.providers.discover", { ...params, sessionId }),
+      /**
+       * Gets current health and version information for a discovered model-provider instance.
+       *
+       * @param params Provider status request parameters.
+       *
+       * @returns Current health information for a provider instance.
+       */
+      getStatus: async (params) => connection.sendRequest("session.providers.getStatus", { ...params, sessionId }),
+      /** @experimental */
+      models: {
+        /**
+         * Lists models installed or otherwise available from a discovered model-provider instance.
+         *
+         * @param params Provider model inventory request parameters.
+         *
+         * @returns Models offered for agent conversations by one provider instance. Adapters exclude known-incompatible models, but retain candidates with unknown capabilities. Listing does not guarantee compatibility.
+         */
+        list: async (params) => connection.sendRequest("session.providers.models.list", { ...params, sessionId }),
+        /**
+         * Translates a discovered model into the provider and model configuration needed to use it, and reports whether each is already registered in this session. Prepares only: it registers nothing, writes nothing, and performs no provider requests.
+         *
+         * @param params A discovered instance and one of its models to translate into provider configuration. Pass back the instance and model as returned by `session.providers.discover` and `session.providers.models.list`.
+         *
+         * @returns Provider configuration prepared from a discovered model. Preparing a plan changes nothing: it neither registers the model with the session nor writes durable configuration. To apply it, pass `provider` and `model` to `session.provider.add`, omitting whichever the dispositions report as already configured.
+         */
+        prepareConfiguration: async (params) => connection.sendRequest("session.providers.models.prepareConfiguration", { ...params, sessionId })
+      }
+    },
     /**
      * Suspends the session while preserving persisted state for later resume.
      *
@@ -785,7 +1383,7 @@ function createSessionRpc(connection, sessionId) {
      *
      * @experimental
      */
-    send: async (params) => connection.sendRequest("session.send", { sessionId, ...params }),
+    send: async (params) => connection.sendRequest("session.send", { ...params, sessionId }),
     /**
      * 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.
      *
@@ -795,7 +1393,7 @@ function createSessionRpc(connection, sessionId) {
      *
      * @experimental
      */
-    sendMessages: async (params) => connection.sendRequest("session.sendMessages", { sessionId, ...params }),
+    sendMessages: async (params) => connection.sendRequest("session.sendMessages", { ...params, sessionId }),
     /** @experimental */
     sandbox: {
       /**
@@ -804,6 +1402,12 @@ function createSessionRpc(connection, sessionId) {
        * @returns Managed sandbox enforcement state for a session.
        */
       getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId }),
+      /**
+       * Lists possible secret-bearing environment variables available to new sandboxed shells that are not already covered by credential masking. Uses local name rules and known-provider host suggestions, never returns secret values, and changes no settings or network permissions. Returns no suggestions while the session is not sandboxed.
+       *
+       * @returns Possible unconfigured secrets in the sandbox shell environment, sorted by variable name, with no secret values.
+       */
+      getCredentialSuggestions: async () => connection.sendRequest("session.sandbox.getCredentialSuggestions", { sessionId }),
       /**
        * Disables sandboxing for the remainder of the current session and approves the referenced pending sandbox-bypass permission request. The request is rejected unless the exact request is still pending and the effective sandbox policy permits bypass.
        *
@@ -811,7 +1415,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of attempting to disable sandboxing for the current session.
        */
-      disableForSession: async (params) => connection.sendRequest("session.sandbox.disableForSession", { sessionId, ...params })
+      disableForSession: async (params) => connection.sendRequest("session.sandbox.disableForSession", { ...params, sessionId }),
+      /**
+       * Adds the path offered by a pending sandbox escalation permission request's sandboxPathGrant to the session's sandbox policy and approves the request, so the blocked operation re-runs inside the sandbox rather than outside it. The request is rejected unless the exact request is still pending, carries a sandboxPathGrant, and the grant still takes effect under the current managed policy. Does not persist the path; hosts that store sandbox settings save it themselves.
+       *
+       * @param params Request to accept the sandbox path grant offered on an active sandbox escalation permission prompt.
+       *
+       * @returns Result of accepting a sandbox path grant.
+       */
+      grantPathForRequest: async (params) => connection.sendRequest("session.sandbox.grantPathForRequest", { ...params, sessionId })
     },
     /**
      * Aborts the current agent turn.
@@ -822,7 +1434,7 @@ function createSessionRpc(connection, sessionId) {
      *
      * @experimental
      */
-    abort: async (params) => connection.sendRequest("session.abort", { sessionId, ...params }),
+    abort: async (params) => connection.sendRequest("session.abort", { ...params, sessionId }),
     /**
      * 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.
      *
@@ -832,7 +1444,7 @@ function createSessionRpc(connection, sessionId) {
      *
      * @experimental
      */
-    interruptMainTurn: async (params) => connection.sendRequest("session.interruptMainTurn", { sessionId, ...params }),
+    interruptMainTurn: async (params) => connection.sendRequest("session.interruptMainTurn", { ...params, sessionId }),
     /**
      * Cancels every running background agent (task-registry subagents plus sidekick agents) without interrupting the main agent loop. Promoted attached shells are left running.
      *
@@ -848,7 +1460,7 @@ function createSessionRpc(connection, sessionId) {
      *
      * @experimental
      */
-    shutdown: async (params) => connection.sendRequest("session.shutdown", { sessionId, ...params }),
+    shutdown: async (params) => connection.sendRequest("session.shutdown", { ...params, sessionId }),
     /** @experimental */
     gitHubAuth: {
       /**
@@ -864,7 +1476,59 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the credential update succeeded.
        */
-      setCredentials: async (params) => connection.sendRequest("session.gitHubAuth.setCredentials", { sessionId, ...params })
+      setCredentials: async (params) => connection.sendRequest("session.gitHubAuth.setCredentials", { ...params, sessionId })
+    },
+    /** @experimental */
+    accounts: {
+      /**
+       * Enumerate a typed accounts collection: the signed-in accounts, or the providers offered for interactive login.
+       *
+       * @param params Enumerate request carrying the typed collection query.
+       *
+       * @returns The enumerated collection, keyed by the same selector as the query.
+       */
+      enumerate: async (params) => connection.sendRequest("session.accounts.enumerate", { ...params, sessionId }),
+      /**
+       * Read one typed accounts datum: the active account, a neutral status summary, or the last authentication errors.
+       *
+       * @param params Read request carrying the typed datum query.
+       *
+       * @returns The read result, keyed by the same selector as the query.
+       */
+      get: async (params) => connection.sendRequest("session.accounts.get", { ...params, sessionId }),
+      /**
+       * Apply one non-interactive accounts mutation: switch the active account, log an account out, or set credentials from a token.
+       *
+       * @param params Mutation request carrying the typed write command.
+       *
+       * @returns Result of a non-interactive accounts mutation.
+       */
+      set: async (params) => connection.sendRequest("session.accounts.set", { ...params, sessionId }),
+      /** @experimental */
+      login: {
+        /**
+         * Begin an interactive login flow for a provider kind (dispatch is kind-only) and return its opaque flow id and first step.
+         *
+         * @param params Begin an interactive login flow for a provider kind. Dispatch is kind-only.
+         *
+         * @returns A started login flow: its opaque id and first step.
+         */
+        begin: async (params) => connection.sendRequest("session.accounts.login.begin", { ...params, sessionId }),
+        /**
+         * Advance an in-flight login flow, optionally fulfilling an input-required step, and return the next step.
+         *
+         * @param params Advance an in-flight login flow, optionally fulfilling an input-required step.
+         *
+         * @returns One step in an interactive login flow. The consumer acts on the step and calls advance to proceed. Browser-open is encoded as two distinct steps by design: `open-url` is CONSUMER-driven (the provider surfaces the authorize URL and the consumer opens it — github.com/GHEC web), while `needs-interaction` is PROVIDER-driven (the provider opens the browser or broker UI itself and does not surface a URL — Entra).
+         */
+        advance: async (params) => connection.sendRequest("session.accounts.login.advance", { ...params, sessionId }),
+        /**
+         * Cancel an in-flight login flow and release its resources.
+         *
+         * @param params Cancel an in-flight login flow.
+         */
+        cancel: async (params) => connection.sendRequest("session.accounts.login.cancel", { ...params, sessionId })
+      }
     },
     /** @experimental */
     debug: {
@@ -875,7 +1539,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of collecting a session debug bundle.
        */
-      collectLogs: async (params) => connection.sendRequest("session.debug.collectLogs", { sessionId, ...params })
+      collectLogs: async (params) => connection.sendRequest("session.debug.collectLogs", { ...params, sessionId })
     },
     /** @experimental */
     canvas: {
@@ -898,13 +1562,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Open canvas instance snapshot.
        */
-      open: async (params) => connection.sendRequest("session.canvas.open", { sessionId, ...params }),
+      open: async (params) => connection.sendRequest("session.canvas.open", { ...params, sessionId }),
       /**
        * Closes an open canvas instance.
        *
        * @param params Canvas close parameters.
        */
-      close: async (params) => connection.sendRequest("session.canvas.close", { sessionId, ...params }),
+      close: async (params) => connection.sendRequest("session.canvas.close", { ...params, sessionId }),
       /** @experimental */
       action: {
         /**
@@ -914,109 +1578,109 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Canvas action invocation result.
          */
-        invoke: async (params) => connection.sendRequest("session.canvas.action.invoke", { sessionId, ...params })
+        invoke: async (params) => connection.sendRequest("session.canvas.action.invoke", { ...params, sessionId })
       }
     },
     /** @experimental */
-    factory: {
+    workflow: {
       /**
-       * Runs a registered factory by name at the top level.
+       * Runs a registered dynamic workflow by name at the top level.
        *
-       * @param params Parameters for invoking a registered factory.
+       * @param params Parameters for invoking a registered workflow.
        *
-       * @returns Complete current or terminal factory run envelope.
+       * @returns Complete current or terminal workflow run envelope.
        */
-      run: async (params) => connection.sendRequest("session.factory.run", { sessionId, ...params }),
+      run: async (params) => connection.sendRequest("session.workflow.run", { ...params, sessionId }),
       /**
-       * Resumes a factory run using its persisted name, arguments, journal, and accounting.
+       * Resumes a dynamic workflow run using its persisted name, arguments, journal, and accounting.
        *
-       * @param params Parameters for resuming a factory run from its persisted identity.
+       * @param params Parameters for resuming a workflow run from its persisted identity.
        *
-       * @returns Resolved persisted factory identity and resumed run envelope.
+       * @returns Resolved persisted workflow identity and resumed run envelope.
        */
-      resume: async (params) => connection.sendRequest("session.factory.resume", { sessionId, ...params }),
+      resume: async (params) => connection.sendRequest("session.workflow.resume", { ...params, sessionId }),
       /**
-       * Gets the current or settled envelope for a factory run.
+       * Gets the current or settled envelope for a dynamic workflow run.
        *
-       * @param params Parameters for retrieving a factory run.
+       * @param params Parameters for retrieving a workflow run.
        *
-       * @returns Complete current or terminal factory run envelope.
+       * @returns Complete current or terminal workflow run envelope.
        */
-      getRun: async (params) => connection.sendRequest("session.factory.getRun", { sessionId, ...params }),
+      getRun: async (params) => connection.sendRequest("session.workflow.getRun", { ...params, sessionId }),
       /**
-       * Lists durable factory runs for this session in creation order.
+       * Lists durable dynamic workflow runs for this session in creation order.
        *
-       * @param params Parameters for paging factory runs.
+       * @param params Parameters for paging workflow runs.
        *
-       * @returns A page of factory runs in durable creation order.
+       * @returns A page of workflow runs in durable creation order.
        */
-      listRuns: async (params) => connection.sendRequest("session.factory.listRuns", { sessionId, ...params }),
+      listRuns: async (params) => connection.sendRequest("session.workflow.listRuns", { ...params, sessionId }),
       /**
-       * Gets durable and live observability detail for one factory run.
+       * Gets durable and live observability detail for one dynamic workflow run.
        *
-       * @param params Parameters for retrieving a factory run.
+       * @param params Parameters for retrieving a workflow run.
        *
-       * @returns Full factory run observability detail.
+       * @returns Full workflow run observability detail.
        */
-      getRunDetail: async (params) => connection.sendRequest("session.factory.getRunDetail", { sessionId, ...params }),
+      getRunDetail: async (params) => connection.sendRequest("session.workflow.getRunDetail", { ...params, sessionId }),
       /**
-       * Pages durable progress for one factory run.
+       * Pages durable progress for one dynamic workflow run.
        *
-       * @param params Parameters for paging factory progress.
+       * @param params Parameters for paging workflow progress.
        *
-       * @returns A bidirectional page of factory progress.
+       * @returns A bidirectional page of workflow progress.
        */
-      getRunProgress: async (params) => connection.sendRequest("session.factory.getRunProgress", { sessionId, ...params }),
+      getRunProgress: async (params) => connection.sendRequest("session.workflow.getRunProgress", { ...params, sessionId }),
       /**
-       * Requests cancellation of a factory run and returns its run envelope.
+       * Requests cancellation of a dynamic workflow run and returns its run envelope.
        *
-       * @param params Parameters for cancelling a factory run.
+       * @param params Parameters for cancelling a workflow run.
        *
-       * @returns Complete current or terminal factory run envelope.
+       * @returns Complete current or terminal workflow run envelope.
        */
-      cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
+      cancel: async (params) => connection.sendRequest("session.workflow.cancel", { ...params, sessionId }),
       /**
-       * Pauses a running factory and returns its settled run envelope.
+       * Pauses a running dynamic workflow and returns its settled run envelope.
        *
-       * @param params Parameters for pausing a running factory.
+       * @param params Parameters for pausing a running workflow.
        *
-       * @returns Complete current or terminal factory run envelope.
+       * @returns Complete current or terminal workflow run envelope.
        */
-      pause: async (params) => connection.sendRequest("session.factory.pause", { sessionId, ...params }),
+      pause: async (params) => connection.sendRequest("session.workflow.pause", { ...params, sessionId }),
       /**
-       * Records a batch of ordered factory progress lines.
+       * Records a batch of ordered dynamic workflow progress lines.
        *
-       * @param params Parameters for recording factory progress.
+       * @param params Parameters for recording workflow progress.
        *
-       * @returns Acknowledgement that a factory request was accepted.
+       * @returns Acknowledgement that a workflow request was accepted.
        */
-      log: async (params) => connection.sendRequest("session.factory.log", { sessionId, ...params }),
+      log: async (params) => connection.sendRequest("session.workflow.log", { ...params, sessionId }),
       /**
-       * Runs one factory-scoped subagent and returns its result.
+       * Runs one dynamic-workflow-scoped subagent and returns its result.
        *
-       * @param params Parameters for one factory-scoped subagent call.
+       * @param params Parameters for one workflow-scoped subagent call.
        *
-       * @returns Result of one factory-scoped subagent call.
+       * @returns Result of one workflow-scoped subagent call.
        */
-      agent: async (params) => connection.sendRequest("session.factory.agent", { sessionId, ...params }),
+      agent: async (params) => connection.sendRequest("session.workflow.agent", { ...params, sessionId }),
       /** @experimental */
       journal: {
         /**
-         * Reads a memoized factory journal entry.
+         * Reads a memoized dynamic workflow journal entry.
          *
-         * @param params Parameters for reading a factory journal entry.
+         * @param params Parameters for reading a workflow journal entry.
          *
-         * @returns Result of reading a factory journal entry.
+         * @returns Result of reading a workflow journal entry.
          */
-        get: async (params) => connection.sendRequest("session.factory.journal.get", { sessionId, ...params }),
+        get: async (params) => connection.sendRequest("session.workflow.journal.get", { ...params, sessionId }),
         /**
-         * Stores a memoized factory journal entry.
+         * Stores a memoized dynamic workflow journal entry.
          *
-         * @param params Parameters for storing a factory journal entry.
+         * @param params Parameters for storing a workflow journal entry.
          *
-         * @returns Acknowledgement that a factory request was accepted.
+         * @returns Acknowledgement that a workflow request was accepted.
          */
-        put: async (params) => connection.sendRequest("session.factory.journal.put", { sessionId, ...params })
+        put: async (params) => connection.sendRequest("session.workflow.journal.put", { ...params, sessionId })
       }
     },
     /** @experimental */
@@ -1034,7 +1698,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The model identifier active on the session after the switch.
        */
-      switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params }),
+      switchTo: async (params) => connection.sendRequest("session.model.switchTo", { ...params, sessionId }),
       /**
        * Requests an Auto preference change without changing the session's selected model. The latest unclaimed request wins; the runtime commits it only after a later prompt using the `auto` model mints a usable model and token pair. A `pending` response confirms that the request was accepted, not that it committed. Observe eventual success through `session.model_change`, failure through the ephemeral `session.auto_tier_switch_failed` event, or current unclaimed state through `session.model.getCurrent`.
        *
@@ -1042,7 +1706,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Immediate acknowledgement and Auto preference snapshot after a switch request. This result never implies that a pending preference committed.
        */
-      switchAutoTier: async (params) => connection.sendRequest("session.model.switchAutoTier", { sessionId, ...params }),
+      switchAutoTier: async (params) => connection.sendRequest("session.model.switchAutoTier", { ...params, sessionId }),
       /**
        * Replaces or clears the host-supplied model allowlist for a running session.
        *
@@ -1050,7 +1714,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The applied host allowlist and effective session model policy after intersection.
        */
-      setAllowedModels: async (params) => connection.sendRequest("session.model.setAllowedModels", { sessionId, ...params }),
+      setAllowedModels: async (params) => connection.sendRequest("session.model.setAllowedModels", { ...params, sessionId }),
       /**
        * Updates the session's reasoning effort without changing the selected model.
        *
@@ -1058,7 +1722,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Update the session's reasoning effort without changing the selected model. Use `switchTo` instead when you also need to change the model. The runtime stores the effort on the session and applies it to subsequent turns.
        */
-      setReasoningEffort: async (params) => connection.sendRequest("session.model.setReasoningEffort", { sessionId, ...params }),
+      setReasoningEffort: async (params) => connection.sendRequest("session.model.setReasoningEffort", { ...params, sessionId }),
       /**
        * Lists models available to this session using its own auth and integration context. Connected hosts (CLI TUI, GitHub App) should call this through the session client so remote sessions return the remote CLI's available models rather than the caller's.
        *
@@ -1066,7 +1730,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The list of models available to this session.
        */
-      list: async (params) => connection.sendRequest("session.model.list", { sessionId, ...params })
+      list: async (params) => connection.sendRequest("session.model.list", { ...params, sessionId })
     },
     /** @experimental */
     mode: {
@@ -1083,7 +1747,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Outcome of a session mode change, including any model switch it triggered and follow-up the host must perform.
        */
-      set: async (params) => connection.sendRequest("session.mode.set", { sessionId, ...params })
+      set: async (params) => connection.sendRequest("session.mode.set", { ...params, sessionId })
     },
     /** @experimental */
     name: {
@@ -1098,7 +1762,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params New friendly name to apply to the session.
        */
-      set: async (params) => connection.sendRequest("session.name.set", { sessionId, ...params }),
+      set: async (params) => connection.sendRequest("session.name.set", { ...params, sessionId }),
       /**
        * Persists an auto-generated session summary as the session's name when no user-set name exists.
        *
@@ -1106,7 +1770,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the auto-generated summary was applied as the session's name.
        */
-      setAuto: async (params) => connection.sendRequest("session.name.setAuto", { sessionId, ...params })
+      setAuto: async (params) => connection.sendRequest("session.name.setAuto", { ...params, sessionId })
     },
     /** @experimental */
     plan: {
@@ -1121,7 +1785,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Replacement contents to write to the session plan file.
        */
-      update: async (params) => connection.sendRequest("session.plan.update", { sessionId, ...params }),
+      update: async (params) => connection.sendRequest("session.plan.update", { ...params, sessionId }),
       /**
        * Deletes the session plan file from the workspace.
        */
@@ -1154,7 +1818,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
        */
-      updateMetadata: async (params) => connection.sendRequest("session.workspaces.updateMetadata", { sessionId, ...params }),
+      updateMetadata: async (params) => connection.sendRequest("session.workspaces.updateMetadata", { ...params, sessionId }),
       /**
        * Ensures a local session workspace exists and returns it.
        *
@@ -1162,7 +1826,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
        */
-      ensure: async (params) => connection.sendRequest("session.workspaces.ensure", { sessionId, ...params }),
+      ensure: async (params) => connection.sendRequest("session.workspaces.ensure", { ...params, sessionId }),
       /**
        * Lists files stored in the session workspace files directory.
        *
@@ -1176,13 +1840,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Contents of the requested workspace file as a UTF-8 string.
        */
-      readFile: async (params) => connection.sendRequest("session.workspaces.readFile", { sessionId, ...params }),
+      readFile: async (params) => connection.sendRequest("session.workspaces.readFile", { ...params, sessionId }),
       /**
        * Creates or overwrites a file in the session workspace files directory.
        *
        * @param params Relative path and UTF-8 content for the workspace file to create or overwrite.
        */
-      createFile: async (params) => connection.sendRequest("session.workspaces.createFile", { sessionId, ...params }),
+      createFile: async (params) => connection.sendRequest("session.workspaces.createFile", { ...params, sessionId }),
       /**
        * Returns metadata for a file or directory in the session workspace files directory.
        *
@@ -1190,25 +1854,25 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Filesystem metadata for a path in the session workspace files directory.
        */
-      statFile: async (params) => connection.sendRequest("session.workspaces.statFile", { sessionId, ...params }),
+      statFile: async (params) => connection.sendRequest("session.workspaces.statFile", { ...params, sessionId }),
       /**
        * Creates a directory in the session workspace files directory.
        *
        * @param params Directory to create within the session workspace files directory.
        */
-      createDirectory: async (params) => connection.sendRequest("session.workspaces.createDirectory", { sessionId, ...params }),
+      createDirectory: async (params) => connection.sendRequest("session.workspaces.createDirectory", { ...params, sessionId }),
       /**
        * Removes a file or directory from the session workspace files directory.
        *
        * @param params File or directory to remove from the session workspace files directory.
        */
-      removePath: async (params) => connection.sendRequest("session.workspaces.removePath", { sessionId, ...params }),
+      removePath: async (params) => connection.sendRequest("session.workspaces.removePath", { ...params, sessionId }),
       /**
        * Renames a file or directory within the session workspace files directory.
        *
        * @param params Source and destination paths for a rename within the session workspace files directory.
        */
-      renamePath: async (params) => connection.sendRequest("session.workspaces.renamePath", { sessionId, ...params }),
+      renamePath: async (params) => connection.sendRequest("session.workspaces.renamePath", { ...params, sessionId }),
       /**
        * Lists workspace checkpoints in chronological order.
        *
@@ -1222,7 +1886,7 @@ 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 }),
+      readCheckpoint: async (params) => connection.sendRequest("session.workspaces.readCheckpoint", { ...params, sessionId }),
       /**
        * Adds a compaction summary checkpoint to the local session workspace.
        *
@@ -1230,7 +1894,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Persisted summary metadata and refreshed workspace metadata.
        */
-      addSummary: async (params) => connection.sendRequest("session.workspaces.addSummary", { sessionId, ...params }),
+      addSummary: async (params) => connection.sendRequest("session.workspaces.addSummary", { ...params, sessionId }),
       /**
        * Truncates local workspace compaction summaries after a rollback.
        *
@@ -1238,7 +1902,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Current workspace metadata for the session, including its absolute filesystem path when available.
        */
-      truncateSummaries: async (params) => connection.sendRequest("session.workspaces.truncateSummaries", { sessionId, ...params }),
+      truncateSummaries: async (params) => connection.sendRequest("session.workspaces.truncateSummaries", { ...params, sessionId }),
       /**
        * Reads the autopilot objective state file from the local session workspace.
        *
@@ -1252,7 +1916,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of writing the autopilot objective file.
        */
-      writeAutopilotObjective: async (params) => connection.sendRequest("session.workspaces.writeAutopilotObjective", { sessionId, ...params }),
+      writeAutopilotObjective: async (params) => connection.sendRequest("session.workspaces.writeAutopilotObjective", { ...params, sessionId }),
       /**
        * Deletes the autopilot objective state file from the local session workspace.
        *
@@ -1272,7 +1936,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Descriptor for the saved paste file, or null when the workspace is unavailable.
        */
-      saveLargePaste: async (params) => connection.sendRequest("session.workspaces.saveLargePaste", { sessionId, ...params }),
+      saveLargePaste: async (params) => connection.sendRequest("session.workspaces.saveLargePaste", { ...params, sessionId }),
       /**
        * 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`.
        *
@@ -1280,7 +1944,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Workspace diff result for the requested mode.
        */
-      diff: async (params) => connection.sendRequest("session.workspaces.diff", { sessionId, ...params })
+      diff: async (params) => connection.sendRequest("session.workspaces.diff", { ...params, sessionId })
     },
     /** @experimental */
     autopilotObjective: {
@@ -1306,7 +1970,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Host-driven completion items for the current composer input. Empty when the host returns no items or does not support completions.
        */
-      request: async (params) => connection.sendRequest("session.completions.request", { sessionId, ...params })
+      request: async (params) => connection.sendRequest("session.completions.request", { ...params, sessionId })
     },
     /** @experimental */
     instructions: {
@@ -1315,7 +1979,22 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Instruction sources loaded for the session, in merge order.
        */
-      getSources: async () => connection.sendRequest("session.instructions.getSources", { sessionId })
+      getSources: async () => connection.sendRequest("session.instructions.getSources", { sessionId }),
+      /**
+       * For local sessions, invalidates instruction discovery and the model-facing prompt, then returns freshly discovered sources. The updated prompt takes effect on the next turn. Remote sessions must reload on their agent host instead.
+       *
+       * @returns Instruction sources loaded for the session, in merge order.
+       */
+      reload: async () => connection.sendRequest("session.instructions.reload", { sessionId })
+    },
+    /** @experimental */
+    customizations: {
+      /**
+       * For local sessions, reconciles repository context and discovered instructions, plugins, skills, agents, hooks, MCP servers, and extensions after files appear or change under the working directory. Independent component failures are returned in outcomes and errors; a rejected call can have partially applied earlier steps. Remote sessions must reload on their agent host instead. The model-facing context is rebuilt on the next turn.
+       *
+       * @returns Results of reloading discovered session customizations. Inspect outcomes for reloaded, skipped, or failed subsystems; a rejection may follow partial mutation. Changes to the model-facing prompt and tools apply on the next turn.
+       */
+      reload: async () => connection.sendRequest("session.customizations.reload", { sessionId })
     },
     /** @experimental */
     fleet: {
@@ -1326,7 +2005,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether fleet mode was successfully activated.
        */
-      start: async (params) => connection.sendRequest("session.fleet.start", { sessionId, ...params })
+      start: async (params) => connection.sendRequest("session.fleet.start", { ...params, sessionId })
     },
     /** @experimental */
     agent: {
@@ -1337,13 +2016,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Agents available to the session.
        */
-      list: async (params) => connection.sendRequest("session.agent.list", { sessionId, ...params }),
+      list: async (params) => connection.sendRequest("session.agent.list", { ...params, sessionId }),
       /**
        * 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 }),
+      setPrompt: async (params) => connection.sendRequest("session.agent.setPrompt", { ...params, sessionId }),
       /**
        * Gets the currently selected custom agent for the session.
        *
@@ -1357,7 +2036,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The newly selected custom agent.
        */
-      select: async (params) => connection.sendRequest("session.agent.select", { sessionId, ...params }),
+      select: async (params) => connection.sendRequest("session.agent.select", { ...params, sessionId }),
       /**
        * Clears the selected custom agent and returns the session to the default agent.
        */
@@ -1378,7 +2057,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Identifier assigned to the newly started background agent task.
        */
-      startAgent: async (params) => connection.sendRequest("session.tasks.startAgent", { sessionId, ...params }),
+      startAgent: async (params) => connection.sendRequest("session.tasks.startAgent", { ...params, sessionId }),
       /**
        * Lists background tasks tracked by the session.
        *
@@ -1392,7 +2071,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of registering or reclaiming a client-owned task.
        */
-      register: async (params) => connection.sendRequest("session.tasks.register", { sessionId, ...params }),
+      register: async (params) => connection.sendRequest("session.tasks.register", { ...params, sessionId }),
       /**
        * Publishes generic progress or a terminal outcome for a client-owned task.
        *
@@ -1400,7 +2079,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of publishing a client-owned task update.
        */
-      update: async (params) => connection.sendRequest("session.tasks.update", { sessionId, ...params }),
+      update: async (params) => connection.sendRequest("session.tasks.update", { ...params, sessionId }),
       /**
        * Refreshes metadata for any detached background shells the runtime knows about.
        *
@@ -1420,7 +2099,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Progress information for the task, or null when no task with that ID is tracked.
        */
-      getProgress: async (params) => connection.sendRequest("session.tasks.getProgress", { sessionId, ...params }),
+      getProgress: async (params) => connection.sendRequest("session.tasks.getProgress", { ...params, sessionId }),
       /**
        * Returns the first sync-waiting task that can currently be promoted to background mode.
        *
@@ -1434,7 +2113,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the task was successfully promoted to background mode.
        */
-      promoteToBackground: async (params) => connection.sendRequest("session.tasks.promoteToBackground", { sessionId, ...params }),
+      promoteToBackground: async (params) => connection.sendRequest("session.tasks.promoteToBackground", { ...params, sessionId }),
       /**
        * Atomically promotes the first promotable sync-waiting task to background mode and returns it.
        *
@@ -1448,7 +2127,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the background task was successfully cancelled.
        */
-      cancel: async (params) => connection.sendRequest("session.tasks.cancel", { sessionId, ...params }),
+      cancel: async (params) => connection.sendRequest("session.tasks.cancel", { ...params, sessionId }),
       /**
        * Removes a completed or cancelled background task from tracking.
        *
@@ -1456,7 +2135,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the task was removed. False when the task does not exist or is still running/idle.
        */
-      remove: async (params) => connection.sendRequest("session.tasks.remove", { sessionId, ...params }),
+      remove: async (params) => connection.sendRequest("session.tasks.remove", { ...params, sessionId }),
       /**
        * Sends a message to a background agent task.
        *
@@ -1464,7 +2143,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the message was delivered, with an error message when delivery failed.
        */
-      sendMessage: async (params) => connection.sendRequest("session.tasks.sendMessage", { sessionId, ...params })
+      sendMessage: async (params) => connection.sendRequest("session.tasks.sendMessage", { ...params, sessionId })
     },
     /** @experimental */
     skills: {
@@ -1485,13 +2164,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Name of the skill to enable for the session.
        */
-      enable: async (params) => connection.sendRequest("session.skills.enable", { sessionId, ...params }),
+      enable: async (params) => connection.sendRequest("session.skills.enable", { ...params, sessionId }),
       /**
        * Disables a skill for the session.
        *
        * @param params Name of the skill to disable for the session.
        */
-      disable: async (params) => connection.sendRequest("session.skills.disable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.skills.disable", { ...params, sessionId }),
       /**
        * Reloads skill definitions for the session.
        *
@@ -1506,11 +2185,17 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     mcp: {
       /**
-       * 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.
+       * Lists materialized MCP servers and their connection status. Cache misses may start and wait for MCP servers.
        *
        * @returns MCP servers configured for the session, with their connection status and host-level state.
        */
       list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
+      /**
+       * Lists effective MCP configuration without starting, restarting, authenticating, or waiting for servers. An optional live observation is from an already materialized matching server; this is not a readiness guarantee.
+       *
+       * @returns Effective MCP configuration with optional live observations from matching already materialized servers.
+       */
+      listConfigured: async () => connection.sendRequest("session.mcp.listConfigured", { sessionId }),
       /**
        * 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.
        *
@@ -1518,19 +2203,19 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 }),
+      listTools: async (params) => connection.sendRequest("session.mcp.listTools", { ...params, sessionId }),
       /**
        * Enables an MCP server for the session.
        *
        * @param params Name of the MCP server to enable for the session.
        */
-      enable: async (params) => connection.sendRequest("session.mcp.enable", { sessionId, ...params }),
+      enable: async (params) => connection.sendRequest("session.mcp.enable", { ...params, sessionId }),
       /**
        * Disables an MCP server for the session.
        *
        * @param params Name of the MCP server to disable for the session.
        */
-      disable: async (params) => connection.sendRequest("session.mcp.disable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.mcp.disable", { ...params, sessionId }),
       /**
        * Reloads MCP server connections for the session.
        */
@@ -1548,7 +2233,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Outcome of an MCP sampling execution: success result, failure error, or cancellation.
        */
-      executeSampling: async (params) => connection.sendRequest("session.mcp.executeSampling", { sessionId, ...params }),
+      executeSampling: async (params) => connection.sendRequest("session.mcp.executeSampling", { ...params, sessionId }),
       /**
        * Cancels an in-flight MCP sampling execution by request ID.
        *
@@ -1556,7 +2241,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether an in-flight sampling execution with the given requestId was found and cancelled.
        */
-      cancelSamplingExecution: async (params) => connection.sendRequest("session.mcp.cancelSamplingExecution", { sessionId, ...params }),
+      cancelSamplingExecution: async (params) => connection.sendRequest("session.mcp.cancelSamplingExecution", { ...params, sessionId }),
       /**
        * Sets how environment-variable values supplied to MCP servers are resolved (direct or indirect).
        *
@@ -1564,7 +2249,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Env-value mode recorded on the session after the update.
        */
-      setEnvValueMode: async (params) => connection.sendRequest("session.mcp.setEnvValueMode", { sessionId, ...params }),
+      setEnvValueMode: async (params) => connection.sendRequest("session.mcp.setEnvValueMode", { ...params, sessionId }),
       /**
        * Removes the auto-managed `github` MCP server when present.
        *
@@ -1576,19 +2261,19 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 }),
+      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { ...params, sessionId }),
       /**
        * 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 }),
+      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { ...params, 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 }),
+      stopServer: async (params) => connection.sendRequest("session.mcp.stopServer", { ...params, sessionId }),
       /**
        * Checks whether a named MCP server is currently running on the session's host.
        *
@@ -1596,7 +2281,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Whether the named MCP server is running.
        */
-      isServerRunning: async (params) => connection.sendRequest("session.mcp.isServerRunning", { sessionId, ...params }),
+      isServerRunning: async (params) => connection.sendRequest("session.mcp.isServerRunning", { ...params, sessionId }),
       /** @experimental */
       oauth: {
         /**
@@ -1606,21 +2291,35 @@ 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 }),
+        handlePendingRequest: async (params) => connection.sendRequest("session.mcp.oauth.handlePendingRequest", { ...params, sessionId }),
         /**
          * 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 }),
+        authenticationStateChanged: async (params) => connection.sendRequest("session.mcp.oauth.authenticationStateChanged", { ...params, sessionId }),
+        /**
+         * Prepares an inert, expiring owned OAuth login bound to the original session requester and exact installation. Does not activate, connect, read credentials or open a browser.
+         *
+         * @param params Effect-free preparation bound to the existing local session, requester and installation, with frozen options.
+         *
+         * @returns An inert runtime-issued login handle. Preparation alone performs no activation or OAuth work.
+         */
+        prepareLogin: async (params) => connection.sendRequest("session.mcp.oauth.prepareLogin", { ...params, sessionId }),
         /**
-         * Starts OAuth authentication for a remote MCP server.
+         * Starts OAuth authentication for a remote MCP server. Owned servers require the original one-use prepareLogin handle and exact installation ID; manual servers retain the existing direct login behaviour.
          *
-         * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.
+         * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback handling, and static OAuth client selection.
          *
          * @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", { ...params, sessionId }),
+        /**
+         * Completes a runtime-managed MCP OAuth login after the authorization server redirects to a host-managed callback URL.
+         *
+         * @param params Host-delivered callback for a runtime-managed MCP OAuth login.
+         */
+        complete: async (params) => connection.sendRequest("session.mcp.oauth.complete", { ...params, sessionId }),
         /**
          * Passively probes a configured remote MCP server to classify whether OAuth is required or a cached/override token is accepted. Does not start OAuth, emit pending OAuth requests, or mutate MCP connection state.
          *
@@ -1628,7 +2327,15 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Passive MCP OAuth probe result. `authenticated` means the server accepted the probe request while an OAuth-origin access token was attached; it does not prove the server required or independently validated that token. The probe does not make a second unauthenticated request. Failed is an expected probe-domain outcome; JSON-RPC errors are reserved for API-call failures.
          */
-        probe: async (params) => connection.sendRequest("session.mcp.oauth.probe", { sessionId, ...params }),
+        probe: async (params) => connection.sendRequest("session.mcp.oauth.probe", { ...params, sessionId }),
+        /**
+         * Cancels the exact owned OAuth login issued to this original session requester, without clearing shared credentials.
+         *
+         * @param params Targets only the original prepared/applying owned login on this exact session requester.
+         *
+         * @returns Honest terminal cancellation result; persistence or recovery failures remain RPC errors.
+         */
+        cancelLogin: async (params) => connection.sendRequest("session.mcp.oauth.cancelLogin", { ...params, sessionId }),
         /**
          * Responds to a pending MCP OAuth authorization request by its request id.
          *
@@ -1636,7 +2343,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the pending MCP OAuth response was accepted.
          */
-        respond: async (params) => connection.sendRequest("session.mcp.oauth.respond", { sessionId, ...params })
+        respond: async (params) => connection.sendRequest("session.mcp.oauth.respond", { ...params, sessionId })
       },
       /** @experimental */
       headers: {
@@ -1647,7 +2354,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the pending MCP headers refresh response was accepted.
          */
-        handlePendingHeadersRefreshRequest: async (params) => connection.sendRequest("session.mcp.headers.handlePendingHeadersRefreshRequest", { sessionId, ...params })
+        handlePendingHeadersRefreshRequest: async (params) => connection.sendRequest("session.mcp.headers.handlePendingHeadersRefreshRequest", { ...params, sessionId })
       },
       /** @experimental */
       apps: {
@@ -1658,7 +2365,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Resource contents returned by the MCP server.
          */
-        readResource: async (params) => connection.sendRequest("session.mcp.apps.readResource", { sessionId, ...params }),
+        readResource: async (params) => connection.sendRequest("session.mcp.apps.readResource", { ...params, sessionId }),
         /**
          * List tools that an MCP App view is allowed to call (SEP-1865 visibility filter). Returns tools whose `_meta.ui.visibility` is unset (default `["model","app"]`) or includes `"app"`.
          *
@@ -1666,7 +2373,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns App-callable tools from the named MCP server.
          */
-        listTools: async (params) => connection.sendRequest("session.mcp.apps.listTools", { sessionId, ...params }),
+        listTools: async (params) => connection.sendRequest("session.mcp.apps.listTools", { ...params, sessionId }),
         /**
          * Call an MCP tool from an MCP App view (SEP-1865). Enforces the visibility check that prevents an app iframe from invoking model-only tools. Returns the standard MCP `CallToolResult`.
          *
@@ -1674,13 +2381,13 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Standard MCP CallToolResult
          */
-        callTool: async (params) => connection.sendRequest("session.mcp.apps.callTool", { sessionId, ...params }),
+        callTool: async (params) => connection.sendRequest("session.mcp.apps.callTool", { ...params, sessionId }),
         /**
          * Replace the host context returned to MCP App guests on `ui/initialize`. Hosts use this to advertise theme, locale, or other metadata to the guest UI.
          *
          * @param params Host context to advertise to MCP App guests.
          */
-        setHostContext: async (params) => connection.sendRequest("session.mcp.apps.setHostContext", { sessionId, ...params }),
+        setHostContext: async (params) => connection.sendRequest("session.mcp.apps.setHostContext", { ...params, sessionId }),
         /**
          * Read the current host context advertised to MCP App guests.
          *
@@ -1694,7 +2401,7 @@ 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 })
+        diagnose: async (params) => connection.sendRequest("session.mcp.apps.diagnose", { ...params, sessionId })
       },
       /** @experimental */
       resources: {
@@ -1705,7 +2412,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Resource contents returned by the MCP server.
          */
-        read: async (params) => connection.sendRequest("session.mcp.resources.read", { sessionId, ...params }),
+        read: async (params) => connection.sendRequest("session.mcp.resources.read", { ...params, sessionId }),
         /**
          * Enumerate one page of resources a connected MCP server exposes (proxies MCP `resources/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
          *
@@ -1713,7 +2420,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns One page of resources advertised by the named MCP server.
          */
-        list: async (params) => connection.sendRequest("session.mcp.resources.list", { sessionId, ...params }),
+        list: async (params) => connection.sendRequest("session.mcp.resources.list", { ...params, sessionId }),
         /**
          * 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`.
          *
@@ -1721,23 +2428,230 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns One page of resource templates advertised by the named MCP server.
          */
-        listTemplates: async (params) => connection.sendRequest("session.mcp.resources.listTemplates", { sessionId, ...params })
+        listTemplates: async (params) => connection.sendRequest("session.mcp.resources.listTemplates", { ...params, sessionId })
+      },
+      /** @experimental */
+      prompts: {
+        /**
+         * Enumerate one page of prompts a connected MCP server exposes (proxies MCP `prompts/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
+         *
+         * @param params MCP server whose prompts to enumerate.
+         *
+         * @returns One page of prompts advertised by the named MCP server.
+         */
+        list: async (params) => connection.sendRequest("session.mcp.prompts.list", { ...params, sessionId }),
+        /**
+         * Get a prompt's messages from a connected MCP server (proxies MCP `prompts/get`). Content is preserved as opaque JSON. Does not send messages to the model, execute tools, or fetch referenced resources.
+         *
+         * @param params MCP server, prompt name, and optional string-valued arguments.
+         *
+         * @returns Prompt messages returned by the MCP server without sending them to the model.
+         */
+        get: async (params) => connection.sendRequest("session.mcp.prompts.get", { ...params, sessionId })
       }
     },
     /** @experimental */
+    diagnostics: {
+      /**
+       * Patches configured session diagnostic sources without restarting their producers. Setting a source level to off clears its retained diagnostics and invalidates cursors selecting that source.
+       *
+       * @param params Patch session diagnostic thresholds for explicitly supplied sources.
+       *
+       * @returns Per-source session diagnostics configuration.
+       */
+      configure: async (params) => connection.sendRequest("session.diagnostics.configure", { ...params, sessionId }),
+      /**
+       * Reads a bounded batch of retained session diagnostics for the selected sources. Records are never consumed and each reader advances independently through its opaque cursor.
+       *
+       * @param params Cursor-based request for session diagnostics. The default limit is 100 (maximum 500); the default waitMs is zero (maximum 30000).
+       *
+       * @returns One cursor-addressed page of retained session diagnostics.
+       */
+      read: async (params) => connection.sendRequest("session.diagnostics.read", { ...params, sessionId })
+    },
+    /** @experimental */
+    connectors: {
+      /**
+       * Returns feature availability and bounded polling limits for the EXPERIMENTAL session connector API. This method never performs a Connector service request.
+       *
+       * @returns Feature detection and hard polling limits for the EXPERIMENTAL session connector API.
+       */
+      getCapabilities: async () => connection.sendRequest("session.connectors.getCapabilities", { sessionId }),
+      /**
+       * Returns the session account selection, or null.
+       *
+       * @returns Session account selection, or null.
+       */
+      getAccount: async () => connection.sendRequest("session.connectors.getAccount", { sessionId }),
+      /**
+       * Returns authoritative session Connector state from current availability, pinned account selection, cached catalog, and live MCP projection without performing a Connector service request.
+       *
+       * @returns Authoritative session connector state. Account IDs are opaque routing identifiers and credentials are never included.
+       */
+      getStatus: async () => connection.sendRequest("session.connectors.getStatus", { sessionId }),
+      /**
+       * Returns the cached Connector catalog for the pinned opaque account selection, fetching it only when this session has no cached catalog.
+       *
+       * @param params Pins a Connector operation to one host-owned GitHub account through its opaque selection ID. Provider tokens are never accepted.
+       *
+       * @returns Validated Connector catalog snapshot cached by the session.
+       */
+      list: async (params) => connection.sendRequest("session.connectors.list", { ...params, sessionId }),
+      /**
+       * Refreshes and validates the Connector catalog for the pinned opaque account selection.
+       *
+       * @param params Pins a Connector operation to one host-owned GitHub account through its opaque selection ID. Provider tokens are never accepted.
+       *
+       * @returns Validated Connector catalog snapshot cached by the session.
+       */
+      refresh: async (params) => connection.sendRequest("session.connectors.refresh", { ...params, sessionId }),
+      /**
+       * Initiates an idempotent Connector connection request without opening a browser. Returns connected when the service is immediately authoritative, consent_required with a validated URL, or pending with an opaque continuation ID.
+       *
+       * @param params Selects one Connector and the pinned host-owned account used for its service and MCP authorization.
+       *
+       * @returns Typed result of initiating or continuing a Connector connection.
+       */
+      connect: async (params) => connection.sendRequest("session.connectors.connect", { ...params, sessionId }),
+      /**
+       * Re-initiates an idempotent Connector connection request without browser or UI effects, with the same typed outcomes as connect.
+       *
+       * @param params Selects one Connector and the pinned host-owned account used for its service and MCP authorization.
+       *
+       * @returns Typed result of initiating or continuing a Connector connection.
+       */
+      reconnect: async (params) => connection.sendRequest("session.connectors.reconnect", { ...params, sessionId }),
+      /**
+       * Continues a pending Connector connection with caller-supplied attempt, interval, and deadline bounds. The runtime never opens the returned consent URL.
+       *
+       * @param params Explicitly bounded continuation of a pending Connector connection.
+       *
+       * @returns Typed result of initiating or continuing a Connector connection.
+       */
+      continueConnection: async (params) => connection.sendRequest("session.connectors.continueConnection", { ...params, sessionId }),
+      /**
+       * Disconnects one Connector for the pinned opaque account selection, refreshes the authoritative catalog, and removes its session-owned MCP projection.
+       *
+       * @param params Selects one Connector and the pinned host-owned account used for its service and MCP authorization.
+       *
+       * @returns Authoritative result after disconnect and MCP reconciliation.
+       */
+      disconnect: async (params) => connection.sendRequest("session.connectors.disconnect", { ...params, sessionId }),
+      /**
+       * Reconciles the authoritative cached or freshly requested Connector catalog into the session Connector MCP projection and returns live status.
+       *
+       * @param params Requests authoritative Connector-to-MCP reconciliation for the pinned account.
+       *
+       * @returns Authoritative session connector state. Account IDs are opaque routing identifiers and credentials are never included.
+       */
+      reconcile: async (params) => connection.sendRequest("session.connectors.reconcile", { ...params, sessionId })
+    },
+    /** @experimental */
+    managedSettings: {
+      /**
+       * Waits for the live session's in-flight managed-settings application, then returns the retained effective snapshot used by runtime enforcement and by `session.managed_settings_resolved`. It does not perform another account, device, or server resolution, and rejects when resolution has not produced a snapshot.
+       *
+       * @returns Effective enterprise managed settings and contributing channels. Session events report applied policy; sessionless resolve reports an account/device snapshot, and compose reports a non-applying preview of candidate documents. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively. Session-local SDK-client policy is included only in session results. Marked experimental while the managed-settings surface stabilizes.
+       */
+      get: async () => connection.sendRequest("session.managedSettings.get", { sessionId })
+    },
+    /** @experimental */
     plugins: {
       /**
-       * Lists plugins installed for the session.
+       * Lists globally installed, live, built-in, and enterprise-managed desired plugins using the live session's authoritative account, working directory, and retained managed policy.
        *
        * @returns Plugins installed for the session, with their enabled state and version metadata.
        */
       list: async () => connection.sendRequest("session.plugins.list", { sessionId }),
+      /**
+       * Installs a plugin using the live session's authoritative account, working directory, and retained managed policy.
+       *
+       * @param params Plugin source resolved relative to the session's authoritative working directory.
+       *
+       * @returns Result of installing a plugin.
+       */
+      install: async (params) => connection.sendRequest("session.plugins.install", { ...params, sessionId }),
+      /**
+       * Uninstalls a plugin when permitted by the live session's retained managed policy.
+       *
+       * @param params Name (or spec) of the plugin to uninstall.
+       */
+      uninstall: async (params) => connection.sendRequest("session.plugins.uninstall", { ...params, sessionId }),
+      /**
+       * Updates an installed plugin using the live session's authoritative account, working directory, and retained managed policy.
+       *
+       * @param params Name (or spec) of the plugin to update.
+       *
+       * @returns Result of updating a single plugin.
+       */
+      update: async (params) => connection.sendRequest("session.plugins.update", { ...params, sessionId }),
+      /**
+       * Enables installed plugins when permitted by the live session's retained managed policy.
+       *
+       * @param params Plugin names (or specs) to enable in the session's authoritative working directory.
+       */
+      enable: async (params) => connection.sendRequest("session.plugins.enable", { ...params, sessionId }),
+      /**
+       * Disables installed plugins when permitted by the live session's retained managed policy.
+       *
+       * @param params Plugin names (or specs) to disable in the session's authoritative working directory.
+       */
+      disable: async (params) => connection.sendRequest("session.plugins.disable", { ...params, sessionId }),
+      /** @experimental */
+      marketplaces: {
+        /**
+         * Lists registered and enterprise-managed desired marketplaces using the live session's retained policy.
+         *
+         * @returns All registered marketplaces, including built-in defaults.
+         */
+        list: async () => connection.sendRequest("session.plugins.marketplaces.list", { sessionId }),
+        /**
+         * Adds a marketplace when permitted by the live session's retained managed policy.
+         *
+         * @param params Marketplace source and optional working directory for relative-path resolution.
+         *
+         * @returns Result of registering a new marketplace.
+         */
+        add: async (params) => connection.sendRequest("session.plugins.marketplaces.add", { ...params, sessionId }),
+        /**
+         * Removes a marketplace when permitted by the live session's retained managed policy.
+         *
+         * @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("session.plugins.marketplaces.remove", { ...params, sessionId }),
+        /**
+         * Browses a marketplace resolved through the live session's working directory and retained managed policy.
+         *
+         * @param params Name of the marketplace whose plugin catalog to fetch.
+         *
+         * @returns Plugins advertised by the marketplace.
+         */
+        browse: async (params) => connection.sendRequest("session.plugins.marketplaces.browse", { ...params, sessionId }),
+        /**
+         * Refreshes marketplaces resolved through the live session's working directory and retained managed policy.
+         *
+         * @param params Optional marketplace name; omit to refresh all.
+         *
+         * @returns Result of refreshing one or more marketplace catalogs.
+         */
+        refresh: async (params) => connection.sendRequest("session.plugins.marketplaces.refresh", { ...params, 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 })
+      reload: async (params) => connection.sendRequest("session.plugins.reload", { ...params, sessionId }),
+      /**
+       * Installs or updates the plugins the session's managed settings require now, without waiting for the next automatic attempt after a failure, then reloads plugins. Reports progress and failures with the same `session.info` and `session.warning` events as automatic preparation. Fails when the runtime does not prepare managed plugins for the session.
+       *
+       * @param params Plugins required by the session's managed settings to install or update again.
+       *
+       * @returns Per-plugin outcomes of retrying the plugins required by the session's managed settings.
+       */
+      retryManaged: async (params) => connection.sendRequest("session.plugins.retryManaged", { ...params, sessionId })
     },
     /** @experimental */
     provider: {
@@ -1748,7 +2662,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 }),
+      getEndpoint: async (params) => connection.sendRequest("session.provider.getEndpoint", { ...params, sessionId }),
       /**
        * Adds BYOK providers and/or models to the session's registry at runtime, extending the additive registry built from the session's `providers`/`models` options. Both fields are optional, so a call may add providers only, models only, or both. Within a single call providers are registered before models, so a model may reference a provider added in the same call; across calls a model may reference any provider already registered (from session creation or a prior add). A model whose referenced provider is not registered by the end of the call is rejected. Newly added models become selectable via `model.list` / `model.switchTo` and are inherited by sub-agents spawned afterwards.
        *
@@ -1756,7 +2670,23 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The selectable model entries synthesized for the models added by this call.
        */
-      add: async (params) => connection.sendRequest("session.provider.add", { sessionId, ...params })
+      add: async (params) => connection.sendRequest("session.provider.add", { ...params, sessionId }),
+      /**
+       * Atomically updates the session's BYOK provider and model registry by applying the supplied snapshot, replacing existing entries, updating models, or removing entries absent from the snapshot.
+       *
+       * @param params Authoritative BYOK provider and model registry snapshot to apply atomically to the session.
+       *
+       * @returns The selectable model entries and selection ids synthesized for the synchronized BYOK models.
+       */
+      sync: async (params) => connection.sendRequest("session.provider.sync", { ...params, sessionId }),
+      /**
+       * Withdraws named host-managed models from the session's BYOK registry, leaving every other entry untouched. The scoped counterpart to `provider.sync`: a snapshot can only describe entries the caller knows about, so using it to remove one model silently withdraws rows registered by another source, such as a plugin calling `provider.add` at runtime. Naming what to remove leaves unrelated entries alone. Selection ids that are not registered are ignored, so withdrawal is idempotent. A provider is removed only when one of the withdrawn models was the last entry referencing it; a provider that simply has no models, which is the normal state while its rows are supplied by catalog discovery, is left in place.
+       *
+       * @param params Host-managed model selection ids to withdraw from the session's BYOK registry.
+       *
+       * @returns What the withdrawal actually removed from the registry.
+       */
+      withdraw: async (params) => connection.sendRequest("session.provider.withdraw", { ...params, sessionId })
     },
     /** @experimental */
     options: {
@@ -1767,7 +2697,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the session options patch was applied successfully.
        */
-      update: async (params) => connection.sendRequest("session.options.update", { sessionId, ...params })
+      update: async (params) => connection.sendRequest("session.options.update", { ...params, sessionId })
     },
     /** @experimental */
     lsp: {
@@ -1776,7 +2706,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Parameters for (re)loading the merged LSP configuration set.
        */
-      initialize: async (params) => connection.sendRequest("session.lsp.initialize", { sessionId, ...params })
+      initialize: async (params) => connection.sendRequest("session.lsp.initialize", { ...params, sessionId })
     },
     /** @experimental */
     extensions: {
@@ -1787,27 +2717,33 @@ function createSessionRpc(connection, sessionId) {
        */
       list: async () => connection.sendRequest("session.extensions.list", { sessionId }),
       /**
-       * Enables an extension for the session.
+       * Enables an extension for the session and persists the preference when the session has a settings store. Hosts synchronizing effective membership should use extensions.reconcile instead.
        *
        * @param params Source-qualified extension identifier to enable for the session.
        */
-      enable: async (params) => connection.sendRequest("session.extensions.enable", { sessionId, ...params }),
+      enable: async (params) => connection.sendRequest("session.extensions.enable", { ...params, sessionId }),
       /**
-       * Disables an extension for the session.
+       * Disables an extension for the session and persists the preference when the session has a settings store. Hosts synchronizing effective membership should use extensions.reconcile instead.
        *
        * @param params Source-qualified extension identifier to disable for the session.
        */
-      disable: async (params) => connection.sendRequest("session.extensions.disable", { sessionId, ...params }),
+      disable: async (params) => connection.sendRequest("session.extensions.disable", { ...params, sessionId }),
       /**
        * Reloads extension definitions and processes for the session.
        */
       reload: async () => connection.sendRequest("session.extensions.reload", { sessionId }),
+      /**
+       * Host-only reconciliation of authoritative session-effective extension membership and enablement. Refreshes runtime-owned discovery and preferences without persisting settings, installing plugins, or restarting unchanged activations. Returns ExtensionList only after required starts and process/contribution cleanup settle. Takes no caller inventory or overrides. Missing controllers, unready/incomplete discovery, unavailable workspaces, superseded inputs, and lifecycle failures are errors, not empty membership. Independently proven revocations may be applied before an error; retry converges without restarting healthy activations. Error data contains lifecycleChangesApplied and code: extension_reconciliation_host_required, extension_reconciliation_unavailable, extension_reconciliation_not_ready, extension_reconciliation_discovery_failed, extension_reconciliation_workspace_unavailable, extension_reconciliation_superseded, or extension_reconciliation_lifecycle_failed. Mark host reconciliation state applied only on success. On older runtimes, method-not-found must not fall back to global discovery and persistent extension disables.
+       *
+       * @returns Extensions discovered for the session, with their current status.
+       */
+      reconcile: async () => connection.sendRequest("session.extensions.reconcile", { sessionId }),
       /**
        * Push attachments into the next user-message turn from an extension. The host should surface them as composer pills and forward them via the next session.send call. Callable only by extension-owned connections.
        *
        * @param params Parameters for session.extensions.sendAttachmentsToMessage.
        */
-      sendAttachmentsToMessage: async (params) => connection.sendRequest("session.extensions.sendAttachmentsToMessage", { sessionId, ...params })
+      sendAttachmentsToMessage: async (params) => connection.sendRequest("session.extensions.sendAttachmentsToMessage", { ...params, sessionId })
     },
     /** @experimental */
     tools: {
@@ -1818,7 +2754,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Canonical result returned by a session tool.
        */
-      execute: async (params) => connection.sendRequest("session.tools.execute", { sessionId, ...params }),
+      execute: async (params) => connection.sendRequest("session.tools.execute", { ...params, sessionId }),
       /**
        * Returns the Rust-owned built-in tool descriptors used to construct the session's offered tool set.
        *
@@ -1826,7 +2762,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Rust-owned built-in tool descriptors for the session.
        */
-      getBuiltinDescriptors: async (params) => connection.sendRequest("session.tools.getBuiltinDescriptors", { sessionId, ...params }),
+      getBuiltinDescriptors: async (params) => connection.sendRequest("session.tools.getBuiltinDescriptors", { ...params, sessionId }),
       /**
        * Projects a completed task_complete tool call into its label-safe session event payload.
        *
@@ -1834,7 +2770,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Task completion notification with summary from the agent
        */
-      taskCompleteEventData: async (params) => connection.sendRequest("session.tools.taskCompleteEventData", { sessionId, ...params }),
+      taskCompleteEventData: async (params) => connection.sendRequest("session.tools.taskCompleteEventData", { ...params, sessionId }),
       /**
        * Provides the result for a pending external tool call.
        *
@@ -1842,7 +2778,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the external tool call result was handled successfully.
        */
-      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { sessionId, ...params }),
+      handlePendingToolCall: async (params) => connection.sendRequest("session.tools.handlePendingToolCall", { ...params, sessionId }),
+      /**
+       * Lists the external tool calls of the session and its sub-agents that are still waiting for session.tools.handlePendingToolCall.
+       *
+       * @returns External tool calls still waiting for a result.
+       */
+      listPendingRequests: async () => connection.sendRequest("session.tools.listPendingRequests", { sessionId }),
       /**
        * Resolves, builds, and validates the runtime tool list for the session.
        *
@@ -1862,7 +2804,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Empty result after replacing the calling connection's externally implemented tools.
        */
-      set: async (params) => connection.sendRequest("session.tools.set", { sessionId, ...params }),
+      set: async (params) => connection.sendRequest("session.tools.set", { ...params, sessionId }),
       /**
        * Sets the current session's live subagent settings override, which takes precedence over persisted user settings until cleared. Persisted user settings remain the source of truth for future sessions.
        *
@@ -1870,7 +2812,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Empty result after applying subagent settings
        */
-      updateSubagentSettings: async (params) => connection.sendRequest("session.tools.updateSubagentSettings", { sessionId, ...params })
+      updateSubagentSettings: async (params) => connection.sendRequest("session.tools.updateSubagentSettings", { ...params, sessionId })
     },
     /** @experimental */
     commands: {
@@ -1881,7 +2823,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Slash commands available in the session, after applying any include/exclude filters.
        */
-      list: async (params) => connection.sendRequest("session.commands.list", { sessionId, ...params }),
+      list: async (params) => connection.sendRequest("session.commands.list", { ...params, sessionId }),
       /**
        * Invokes a slash command in the session.
        *
@@ -1889,7 +2831,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of invoking the slash command (text output, prompt to send to the agent, completion, or subcommand selection).
        */
-      invoke: async (params) => connection.sendRequest("session.commands.invoke", { sessionId, ...params }),
+      invoke: async (params) => connection.sendRequest("session.commands.invoke", { ...params, sessionId }),
       /**
        * Reports completion of a pending client-handled slash command.
        *
@@ -1897,7 +2839,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the pending client-handled command was completed successfully.
        */
-      handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { sessionId, ...params }),
+      handlePendingCommand: async (params) => connection.sendRequest("session.commands.handlePendingCommand", { ...params, sessionId }),
       /**
        * Executes a slash command synchronously and returns any error.
        *
@@ -1905,7 +2847,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Error message produced while executing the command, if any.
        */
-      execute: async (params) => connection.sendRequest("session.commands.execute", { sessionId, ...params }),
+      execute: async (params) => connection.sendRequest("session.commands.execute", { ...params, sessionId }),
       /**
        * Enqueues a slash command for FIFO processing on the local session.
        *
@@ -1913,7 +2855,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the command was accepted into the local execution queue.
        */
-      enqueue: async (params) => connection.sendRequest("session.commands.enqueue", { sessionId, ...params }),
+      enqueue: async (params) => connection.sendRequest("session.commands.enqueue", { ...params, sessionId }),
       /**
        * Reports whether the host actually executed a queued command and whether to continue processing.
        *
@@ -1921,7 +2863,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the queued-command response was matched to a pending request.
        */
-      respondToQueuedCommand: async (params) => connection.sendRequest("session.commands.respondToQueuedCommand", { sessionId, ...params })
+      respondToQueuedCommand: async (params) => connection.sendRequest("session.commands.respondToQueuedCommand", { ...params, sessionId })
     },
     /** @experimental */
     telemetry: {
@@ -1936,7 +2878,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Feature override key/value pairs to attach to subsequent telemetry events from this session.
        */
-      setFeatureOverrides: async (params) => connection.sendRequest("session.telemetry.setFeatureOverrides", { sessionId, ...params })
+      setFeatureOverrides: async (params) => connection.sendRequest("session.telemetry.setFeatureOverrides", { ...params, sessionId })
     },
     /** @experimental */
     ui: {
@@ -1947,7 +2889,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Completed transient query. Ordered chunks and the terminal outcome are also delivered through `ui.ephemeral_query` session events while it runs.
        */
-      ephemeralQuery: async (params) => connection.sendRequest("session.ui.ephemeralQuery", { sessionId, ...params }),
+      ephemeralQuery: async (params) => connection.sendRequest("session.ui.ephemeralQuery", { ...params, sessionId }),
       /**
        * Requests structured input from a UI-capable client.
        *
@@ -1955,7 +2897,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The elicitation response (accept with form values, decline, or cancel)
        */
-      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { sessionId, ...params }),
+      elicitation: async (params) => connection.sendRequest("session.ui.elicitation", { ...params, sessionId }),
       /**
        * Provides the user response for a pending elicitation request.
        *
@@ -1963,7 +2905,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the elicitation response was accepted; false if it was already resolved by another client.
        */
-      handlePendingElicitation: async (params) => connection.sendRequest("session.ui.handlePendingElicitation", { sessionId, ...params }),
+      handlePendingElicitation: async (params) => connection.sendRequest("session.ui.handlePendingElicitation", { ...params, sessionId }),
       /**
        * Resolves a pending `user_input.requested` event with the user's response.
        *
@@ -1971,7 +2913,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the pending UI request was resolved by this call.
        */
-      handlePendingUserInput: async (params) => connection.sendRequest("session.ui.handlePendingUserInput", { sessionId, ...params }),
+      handlePendingUserInput: async (params) => connection.sendRequest("session.ui.handlePendingUserInput", { ...params, sessionId }),
       /**
        * Resolves a pending `sampling.requested` event with a sampling result, or rejects it.
        *
@@ -1979,7 +2921,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the pending UI request was resolved by this call.
        */
-      handlePendingSampling: async (params) => connection.sendRequest("session.ui.handlePendingSampling", { sessionId, ...params }),
+      handlePendingSampling: async (params) => connection.sendRequest("session.ui.handlePendingSampling", { ...params, sessionId }),
       /**
        * Resolves a pending `auto_mode_switch.requested` event with the user's accept/decline decision.
        *
@@ -1987,7 +2929,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the pending UI request was resolved by this call.
        */
-      handlePendingAutoModeSwitch: async (params) => connection.sendRequest("session.ui.handlePendingAutoModeSwitch", { sessionId, ...params }),
+      handlePendingAutoModeSwitch: async (params) => connection.sendRequest("session.ui.handlePendingAutoModeSwitch", { ...params, sessionId }),
       /**
        * Resolves a pending `session_limits_exhausted.requested` event with the user's selected limit action.
        *
@@ -1995,7 +2937,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the pending UI request was resolved by this call.
        */
-      handlePendingSessionLimitsExhausted: async (params) => connection.sendRequest("session.ui.handlePendingSessionLimitsExhausted", { sessionId, ...params }),
+      handlePendingSessionLimitsExhausted: async (params) => connection.sendRequest("session.ui.handlePendingSessionLimitsExhausted", { ...params, sessionId }),
       /**
        * Resolves a pending `exit_plan_mode.requested` event with the user's response.
        *
@@ -2003,7 +2945,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the pending UI request was resolved by this call.
        */
-      handlePendingExitPlanMode: async (params) => connection.sendRequest("session.ui.handlePendingExitPlanMode", { sessionId, ...params }),
+      handlePendingExitPlanMode: async (params) => connection.sendRequest("session.ui.handlePendingExitPlanMode", { ...params, sessionId }),
       /**
        * Registers an in-process handler for auto-mode-switch requests so the server bridge skips dispatch.
        *
@@ -2017,7 +2959,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the handle was active and the registration count was decremented.
        */
-      unregisterDirectAutoModeSwitchHandler: async (params) => connection.sendRequest("session.ui.unregisterDirectAutoModeSwitchHandler", { sessionId, ...params })
+      unregisterDirectAutoModeSwitchHandler: async (params) => connection.sendRequest("session.ui.unregisterDirectAutoModeSwitchHandler", { ...params, sessionId })
     },
     /** @experimental */
     permissions: {
@@ -2028,7 +2970,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the operation succeeded.
        */
-      configure: async (params) => connection.sendRequest("session.permissions.configure", { sessionId, ...params }),
+      configure: async (params) => connection.sendRequest("session.permissions.configure", { ...params, sessionId }),
       /**
        * Provides a decision for a pending tool permission request.
        *
@@ -2036,7 +2978,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the permission decision was applied; false when the request was already resolved.
        */
-      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params }),
+      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { ...params, sessionId }),
       /**
        * Reconstructs the set of pending tool permission requests from the session's event history.
        *
@@ -2050,7 +2992,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the operation succeeded.
        */
-      setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { sessionId, ...params }),
+      setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { ...params, sessionId }),
       /**
        * Sets the permission mode for the session. `manual` follows the normal approval flow, `assisted` attaches LLM safety recommendations, and `allow-all` automatically approves permission requests. The result returns the authoritative post-mutation mode so callers can update local state without racing the `session.permissions_changed` notification.
        *
@@ -2058,7 +3000,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the requested permission mode was applied and reports the authoritative post-mutation mode.
        */
-      setMode: async (params) => connection.sendRequest("session.permissions.setMode", { sessionId, ...params }),
+      setMode: async (params) => connection.sendRequest("session.permissions.setMode", { ...params, sessionId }),
       /**
        * Returns the current permission mode for the session.
        *
@@ -2072,7 +3014,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the operation succeeded.
        */
-      modifyRules: async (params) => connection.sendRequest("session.permissions.modifyRules", { sessionId, ...params }),
+      modifyRules: async (params) => connection.sendRequest("session.permissions.modifyRules", { ...params, sessionId }),
       /**
        * Sets whether the client wants permission prompts bridged into session events.
        *
@@ -2080,15 +3022,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the operation succeeded.
        */
-      setRequired: async (params) => connection.sendRequest("session.permissions.setRequired", { sessionId, ...params }),
+      setRequired: async (params) => connection.sendRequest("session.permissions.setRequired", { ...params, sessionId }),
       /**
-       * Clears session-scoped tool permission approvals.
+       * Clears session-scoped tool approvals and, for full resets, exact session-approved paths.
        *
-       * @param params Clears session-scoped tool permission approvals, and optionally the location-scoped ones.
+       * @param params Clears session-scoped tool approvals and optionally clears location-scoped approvals and exact session-approved paths.
        *
        * @returns Indicates whether the operation succeeded.
        */
-      resetSessionApprovals: async (params) => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId, ...params }),
+      resetSessionApprovals: async (params) => connection.sendRequest("session.permissions.resetSessionApprovals", { ...params, sessionId }),
       /**
        * Notifies the runtime that a permission prompt UI has been shown to the user.
        *
@@ -2096,13 +3038,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the operation succeeded.
        */
-      notifyPromptShown: async (params) => connection.sendRequest("session.permissions.notifyPromptShown", { sessionId, ...params }),
+      notifyPromptShown: async (params) => connection.sendRequest("session.permissions.notifyPromptShown", { ...params, sessionId }),
       /** @experimental */
       paths: {
         /**
-         * Returns the session's allowed directories and primary working directory.
+         * Returns the session's recursive directory grants, exact session-approved paths, and primary working directory.
          *
-         * @returns Snapshot of the session's allow-listed directories and primary working directory.
+         * @returns Snapshot of the session's recursive directory grants, exact session-approved paths, and primary working directory.
          */
         list: async () => connection.sendRequest("session.permissions.paths.list", { sessionId }),
         /**
@@ -2112,7 +3054,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the operation succeeded.
          */
-        add: async (params) => connection.sendRequest("session.permissions.paths.add", { sessionId, ...params }),
+        add: async (params) => connection.sendRequest("session.permissions.paths.add", { ...params, sessionId }),
         /**
          * Updates the session's primary working directory used by the permission policy.
          *
@@ -2120,7 +3062,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the operation succeeded.
          */
-        updatePrimary: async (params) => connection.sendRequest("session.permissions.paths.updatePrimary", { sessionId, ...params }),
+        updatePrimary: async (params) => connection.sendRequest("session.permissions.paths.updatePrimary", { ...params, sessionId }),
         /**
          * Reports whether a path falls within any of the session's allowed directories.
          *
@@ -2128,7 +3070,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the supplied path is within the session's allowed directories.
          */
-        isPathWithinAllowedDirectories: async (params) => connection.sendRequest("session.permissions.paths.isPathWithinAllowedDirectories", { sessionId, ...params }),
+        isPathWithinAllowedDirectories: async (params) => connection.sendRequest("session.permissions.paths.isPathWithinAllowedDirectories", { ...params, sessionId }),
         /**
          * Reports whether a path falls within the session's workspace (primary) directory.
          *
@@ -2136,7 +3078,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the supplied path is within the session's workspace directory.
          */
-        isPathWithinWorkspace: async (params) => connection.sendRequest("session.permissions.paths.isPathWithinWorkspace", { sessionId, ...params })
+        isPathWithinWorkspace: async (params) => connection.sendRequest("session.permissions.paths.isPathWithinWorkspace", { ...params, sessionId })
       },
       /** @experimental */
       locations: {
@@ -2147,7 +3089,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Resolved location-permissions key and type.
          */
-        resolve: async (params) => connection.sendRequest("session.permissions.locations.resolve", { sessionId, ...params }),
+        resolve: async (params) => connection.sendRequest("session.permissions.locations.resolve", { ...params, sessionId }),
         /**
          * Applies persisted location-scoped tool approvals and allowed directories for a working directory to this session's permission service.
          *
@@ -2155,7 +3097,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Summary of persisted location permissions applied to the session.
          */
-        apply: async (params) => connection.sendRequest("session.permissions.locations.apply", { sessionId, ...params }),
+        apply: async (params) => connection.sendRequest("session.permissions.locations.apply", { ...params, sessionId }),
         /**
          * Persists a tool approval for a permission location and applies its rules to this session's live permission service.
          *
@@ -2163,7 +3105,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the operation succeeded.
          */
-        addToolApproval: async (params) => connection.sendRequest("session.permissions.locations.addToolApproval", { sessionId, ...params })
+        addToolApproval: async (params) => connection.sendRequest("session.permissions.locations.addToolApproval", { ...params, sessionId })
       },
       /** @experimental */
       folderTrust: {
@@ -2174,7 +3116,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Folder trust check result.
          */
-        isTrusted: async (params) => connection.sendRequest("session.permissions.folderTrust.isTrusted", { sessionId, ...params }),
+        isTrusted: async (params) => connection.sendRequest("session.permissions.folderTrust.isTrusted", { ...params, sessionId }),
         /**
          * Adds a folder to the user's trusted folders list.
          *
@@ -2182,7 +3124,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the operation succeeded.
          */
-        addTrusted: async (params) => connection.sendRequest("session.permissions.folderTrust.addTrusted", { sessionId, ...params })
+        addTrusted: async (params) => connection.sendRequest("session.permissions.folderTrust.addTrusted", { ...params, sessionId })
       },
       /** @experimental */
       urls: {
@@ -2193,7 +3135,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @returns Indicates whether the operation succeeded.
          */
-        setUnrestrictedMode: async (params) => connection.sendRequest("session.permissions.urls.setUnrestrictedMode", { sessionId, ...params })
+        setUnrestrictedMode: async (params) => connection.sendRequest("session.permissions.urls.setUnrestrictedMode", { ...params, sessionId })
       }
     },
     /**
@@ -2205,7 +3147,7 @@ function createSessionRpc(connection, sessionId) {
      *
      * @experimental
      */
-    log: async (params) => connection.sendRequest("session.log", { sessionId, ...params }),
+    log: async (params) => connection.sendRequest("session.log", { ...params, sessionId }),
     /** @experimental */
     metadata: {
       /**
@@ -2227,7 +3169,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.
        */
-      updateClientMetadata: async (params) => connection.sendRequest("session.metadata.updateClientMetadata", { sessionId, ...params }),
+      updateClientMetadata: async (params) => connection.sendRequest("session.metadata.updateClientMetadata", { ...params, sessionId }),
       /**
        * Reports whether the local session is currently processing user/agent messages.
        *
@@ -2247,7 +3189,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Token breakdown for the session's current context window, or null if uninitialized.
        */
-      contextInfo: async (params) => connection.sendRequest("session.metadata.contextInfo", { sessionId, ...params }),
+      contextInfo: async (params) => connection.sendRequest("session.metadata.contextInfo", { ...params, sessionId }),
       /**
        * Returns the experimental per-source attribution breakdown of the session's current context window as a flat list of entries (skills, subagents, MCP servers, built-in tools, plugin rollups, system/tool-definition costs, with nesting via parentId), plus the successful compaction count. The heaviest individual messages are available separately via `metadata.getContextHeaviestMessages`. Returns null until the session has initialized its system prompt and tool metadata.
        *
@@ -2261,7 +3203,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The heaviest individual messages in the session's context window, most-expensive first.
        */
-      getContextHeaviestMessages: async (params) => connection.sendRequest("session.metadata.getContextHeaviestMessages", { sessionId, ...params }),
+      getContextHeaviestMessages: async (params) => connection.sendRequest("session.metadata.getContextHeaviestMessages", { ...params, sessionId }),
       /**
        * 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.
        *
@@ -2269,7 +3211,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 }),
+      recordContextChange: async (params) => connection.sendRequest("session.metadata.recordContextChange", { ...params, sessionId }),
       /**
        * 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.
        *
@@ -2277,7 +3219,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 }),
+      setWorkingDirectory: async (params) => connection.sendRequest("session.metadata.setWorkingDirectory", { ...params, sessionId }),
       /**
        * Re-tokenizes the session's existing messages against a model and returns aggregate token totals.
        *
@@ -2285,7 +3227,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Re-tokenize the session's existing messages against `modelId` and return the token totals. Useful for hosts that want an initial estimate of context usage on session resume, before the next agent turn fires `session.context_info_changed` events. Returns zeros for an empty session.
        */
-      recomputeContextTokens: async (params) => connection.sendRequest("session.metadata.recomputeContextTokens", { sessionId, ...params })
+      recomputeContextTokens: async (params) => connection.sendRequest("session.metadata.recomputeContextTokens", { ...params, sessionId })
     },
     /** @experimental */
     contentExclusion: {
@@ -2296,18 +3238,18 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Batch content-exclusion result. Callers must fail closed when policy evaluation is unavailable.
        */
-      checkPaths: async (params) => connection.sendRequest("session.contentExclusion.checkPaths", { sessionId, ...params })
+      checkPaths: async (params) => connection.sendRequest("session.contentExclusion.checkPaths", { ...params, sessionId })
     },
     /** @experimental */
     shell: {
       /**
-       * 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.
+       * Starts a shell command, returning an RPC error if it cannot be spawned. 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.
+       * @param params Shell command to run, with optional working directory and timeout in milliseconds. Spawn failures return an RPC error.
        *
-       * @returns Identifier of the spawned process, used to correlate streamed output and exit notifications.
+       * @returns Identifier of the spawned shell process, usable with shell.kill while the process is running.
        */
-      exec: async (params) => connection.sendRequest("session.shell.exec", { sessionId, ...params }),
+      exec: async (params) => connection.sendRequest("session.shell.exec", { ...params, sessionId }),
       /**
        * 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.
        *
@@ -2315,7 +3257,7 @@ 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", { ...params, sessionId }),
       /**
        * Executes a user-requested shell command through the session runtime.
        *
@@ -2323,7 +3265,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of a user-requested shell command.
        */
-      executeUserRequested: async (params) => connection.sendRequest("session.shell.executeUserRequested", { sessionId, ...params }),
+      executeUserRequested: async (params) => connection.sendRequest("session.shell.executeUserRequested", { ...params, sessionId }),
       /**
        * Cancels a user-requested shell command by request ID.
        *
@@ -2331,7 +3273,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Cancellation result for a user-requested shell command.
        */
-      cancelUserRequested: async (params) => connection.sendRequest("session.shell.cancelUserRequested", { sessionId, ...params })
+      cancelUserRequested: async (params) => connection.sendRequest("session.shell.cancelUserRequested", { ...params, sessionId })
     },
     /** @experimental */
     history: {
@@ -2342,7 +3284,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Compaction outcome with the number of tokens and messages removed, summary text, and the resulting context window breakdown.
        */
-      compact: async (params) => connection.sendRequest("session.history.compact", { sessionId, ...params }),
+      compact: async (params) => connection.sendRequest("session.history.compact", { ...params, sessionId }),
       /**
        * Truncates persisted session history to a specific event.
        *
@@ -2350,7 +3292,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Number of events that were removed by the truncation.
        */
-      truncate: async (params) => connection.sendRequest("session.history.truncate", { sessionId, ...params }),
+      truncate: async (params) => connection.sendRequest("session.history.truncate", { ...params, sessionId }),
       /**
        * 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.
        *
@@ -2364,7 +3306,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Files and aggregate changes for a prospective rewind.
        */
-      previewRewind: async (params) => connection.sendRequest("session.history.previewRewind", { sessionId, ...params }),
+      previewRewind: async (params) => connection.sendRequest("session.history.previewRewind", { ...params, sessionId }),
       /**
        * 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.
        *
@@ -2372,7 +3314,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Structured outcome of a rewind request.
        */
-      rewind: async (params) => connection.sendRequest("session.history.rewind", { sessionId, ...params }),
+      rewind: async (params) => connection.sendRequest("session.history.rewind", { ...params, sessionId }),
       /**
        * Cancels any in-progress background compaction on a local session.
        *
@@ -2398,7 +3340,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @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 })
+      clearContext: async (params) => connection.sendRequest("session.history.clearContext", { ...params, sessionId })
     },
     /** @experimental */
     queue: {
@@ -2415,7 +3357,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of moving a queued item.
        */
-      moveItem: async (params) => connection.sendRequest("session.queue.moveItem", { sessionId, ...params }),
+      moveItem: async (params) => connection.sendRequest("session.queue.moveItem", { ...params, sessionId }),
       /**
        * Inserts a new queued message at a public visible position.
        *
@@ -2423,7 +3365,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of inserting a queued message.
        */
-      insertAt: async (params) => connection.sendRequest("session.queue.insertAt", { sessionId, ...params }),
+      insertAt: async (params) => connection.sendRequest("session.queue.insertAt", { ...params, sessionId }),
       /**
        * Removes an addressable queued item by its stable id.
        *
@@ -2431,7 +3373,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of removing a queued item.
        */
-      removeAt: async (params) => connection.sendRequest("session.queue.removeAt", { sessionId, ...params }),
+      removeAt: async (params) => connection.sendRequest("session.queue.removeAt", { ...params, sessionId }),
       /**
        * Updates the text of an addressable single-message queue item.
        *
@@ -2439,7 +3381,23 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of editing a queued message.
        */
-      updateText: async (params) => connection.sendRequest("session.queue.updateText", { sessionId, ...params }),
+      updateText: async (params) => connection.sendRequest("session.queue.updateText", { ...params, sessionId }),
+      /**
+       * Atomically withdraws an unchanged user message of a local session: from the queued or steering lane while unconsumed, or from the running turn it started while the model has not answered it and nothing the user sent after it is pending. Withdrawing from the running turn interrupts that turn and removes its events from history. A client retaining the original draft may restore it only when removed is true.
+       *
+       * @param params Conditional withdrawal of a single user message, from its queue or from the running turn it started.
+       *
+       * @returns Result of withdrawing a user message.
+       */
+      withdrawMessage: async (params) => connection.sendRequest("session.queue.withdrawMessage", { ...params, sessionId }),
+      /**
+       * Atomically appends text and attachments to an unchanged, unconsumed local steering message. Returns updated=false if delivery or withdrawal already claimed the message.
+       *
+       * @param params Append to one pending steering message without changing its identity or delivery position.
+       *
+       * @returns Result of editing a queued message.
+       */
+      appendSteering: async (params) => connection.sendRequest("session.queue.appendSteering", { ...params, sessionId }),
       /**
        * Duplicates an addressable queued item immediately after its source.
        *
@@ -2447,13 +3405,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of duplicating a queued item.
        */
-      duplicateAt: async (params) => connection.sendRequest("session.queue.duplicateAt", { sessionId, ...params }),
+      duplicateAt: async (params) => connection.sendRequest("session.queue.duplicateAt", { ...params, sessionId }),
       /**
        * 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 }),
+      setDrainPaused: async (params) => connection.sendRequest("session.queue.setDrainPaused", { ...params, sessionId }),
       /**
        * Moves an addressable queued message into the live turn's steering lane.
        *
@@ -2461,7 +3419,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of trying to steer a queued message into a live turn.
        */
-      sendNow: async (params) => connection.sendRequest("session.queue.sendNow", { sessionId, ...params }),
+      sendNow: async (params) => connection.sendRequest("session.queue.sendNow", { ...params, sessionId }),
       /**
        * Removes the most recently queued user-facing item (LIFO).
        *
@@ -2482,7 +3440,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Batch of session events returned by a read, with cursor and continuation metadata.
        */
-      read: async (params) => connection.sendRequest("session.eventLog.read", { sessionId, ...params }),
+      read: async (params) => connection.sendRequest("session.eventLog.read", { ...params, sessionId }),
       /**
        * Returns a snapshot of the current tail cursor without consuming events.
        *
@@ -2496,7 +3454,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Opaque handle representing an event-type interest registration.
        */
-      registerInterest: async (params) => connection.sendRequest("session.eventLog.registerInterest", { sessionId, ...params }),
+      registerInterest: async (params) => connection.sendRequest("session.eventLog.registerInterest", { ...params, sessionId }),
       /**
        * Releases a consumer's previously-registered interest in an event type.
        *
@@ -2504,7 +3462,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether the operation succeeded.
        */
-      releaseInterest: async (params) => connection.sendRequest("session.eventLog.releaseInterest", { sessionId, ...params })
+      releaseInterest: async (params) => connection.sendRequest("session.eventLog.releaseInterest", { ...params, sessionId })
     },
     /** @experimental */
     usage: {
@@ -2516,6 +3474,27 @@ function createSessionRpc(connection, sessionId) {
       getMetrics: async () => connection.sendRequest("session.usage.getMetrics", { sessionId })
     },
     /** @experimental */
+    quota: {
+      /**
+       * Gets the session's current quota and account projection without making a network request.
+       *
+       * @returns The incumbent session-owned quota and account projection.
+       */
+      get: async () => connection.sendRequest("session.quota.get", { sessionId }),
+      /**
+       * Refreshes the session's provider model catalog bypassing its cache, folds quota snapshots into session state, and returns the updated projection. Failures leave the last known quota intact.
+       *
+       * @returns The incumbent session-owned quota and account projection.
+       */
+      refresh: async () => connection.sendRequest("session.quota.refresh", { sessionId }),
+      /**
+       * Returns and clears the session's pending quota warnings. Reading or refreshing quota does not drain warnings.
+       *
+       * @returns Pending warnings returned and cleared by session.quota.takeWarnings.
+       */
+      takeWarnings: async () => connection.sendRequest("session.quota.takeWarnings", { 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.
@@ -2524,7 +3503,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Prediction result. Available results include prediction details; unavailable results include an explicit reason.
        */
-      predict: async (params) => connection.sendRequest("session.limitPrediction.predict", { sessionId, ...params })
+      predict: async (params) => connection.sendRequest("session.limitPrediction.predict", { ...params, sessionId })
     },
     /** @experimental */
     remote: {
@@ -2535,7 +3514,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns GitHub URL for the session and a flag indicating whether remote steering is enabled.
        */
-      enable: async (params) => connection.sendRequest("session.remote.enable", { sessionId, ...params }),
+      enable: async (params) => connection.sendRequest("session.remote.enable", { ...params, sessionId }),
       /**
        * Disables remote session export and steering.
        */
@@ -2547,7 +3526,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Persist a steerability change as a `session.remote_steerable_changed` event. Used by the host (CLI / SDK consumer) when it has just finished enabling or disabling steering on a remote exporter that the runtime does not directly own.
        */
-      notifySteerableChanged: async (params) => connection.sendRequest("session.remote.notifySteerableChanged", { sessionId, ...params })
+      notifySteerableChanged: async (params) => connection.sendRequest("session.remote.notifySteerableChanged", { ...params, sessionId })
     },
     /** @experimental */
     visibility: {
@@ -2564,7 +3543,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Effective sharing status and shareable GitHub URL after updating session visibility.
        */
-      set: async (params) => connection.sendRequest("session.visibility.set", { sessionId, ...params })
+      set: async (params) => connection.sendRequest("session.visibility.set", { ...params, sessionId })
     },
     /** @experimental */
     schedule: {
@@ -2581,7 +3560,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Remove a scheduled prompt by id. The result entry is omitted if the id was unknown.
        */
-      stop: async (params) => connection.sendRequest("session.schedule.stop", { sessionId, ...params })
+      stop: async (params) => connection.sendRequest("session.schedule.stop", { ...params, sessionId })
     }
   };
 }
@@ -2594,7 +3573,7 @@ function createInternalSessionRpc(connection, sessionId) {
      *
      * @experimental
      */
-    sendSystemNotification: async (params) => connection.sendRequest("session.sendSystemNotification", { sessionId, ...params }),
+    sendSystemNotification: async (params) => connection.sendRequest("session.sendSystemNotification", { ...params, sessionId }),
     /** @experimental */
     gitHubAuth: {
       /**
@@ -2622,13 +3601,13 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Authentication credentials accepted only at native protocol ingress. Runtime outputs use credential-free `AuthIdentity` metadata.
        */
-      login: async (params) => connection.sendRequest("session.gitHubAuth.login", { sessionId, ...params }),
+      login: async (params) => connection.sendRequest("session.gitHubAuth.login", { ...params, sessionId }),
       /**
        * Switches the session to another available authentication.
        *
        * @param params Parameters for switching the session's active authentication.
        */
-      switchToAuth: async (params) => connection.sendRequest("session.gitHubAuth.switchToAuth", { sessionId, ...params }),
+      switchToAuth: async (params) => connection.sendRequest("session.gitHubAuth.switchToAuth", { ...params, sessionId }),
       /**
        * Logs out the session's current GitHub authentication.
        *
@@ -2642,7 +3621,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Whether the requested authentication was logged out.
        */
-      logoutUser: async (params) => connection.sendRequest("session.gitHubAuth.logoutUser", { sessionId, ...params }),
+      logoutUser: async (params) => connection.sendRequest("session.gitHubAuth.logoutUser", { ...params, sessionId }),
       /**
        * Gets validation errors from the most recent authentication attempt.
        *
@@ -2659,39 +3638,39 @@ function createInternalSessionRpc(connection, sessionId) {
          *
          * @param params Internal canvas provider registration parameters.
          */
-        register: async (params) => connection.sendRequest("session.canvas.provider.register", { sessionId, ...params }),
+        register: async (params) => connection.sendRequest("session.canvas.provider.register", { ...params, sessionId }),
         /**
          * Unregisters an internal canvas provider connection.
          *
          * @param params Internal canvas provider unregistration parameters.
          */
-        unregister: async (params) => connection.sendRequest("session.canvas.provider.unregister", { sessionId, ...params })
+        unregister: async (params) => connection.sendRequest("session.canvas.provider.unregister", { ...params, sessionId })
       }
     },
     /** @experimental */
-    factory: {
+    workflow: {
       /**
-       * Internal tool-originated factory invocation.
+       * Internal tool-originated dynamic workflow invocation.
        *
-       * @param params Internal parameters for invoking a registered factory from a tool.
+       * @param params Internal parameters for invoking a registered workflow from a tool.
        *
-       * @returns Complete current or terminal factory run envelope.
+       * @returns Complete current or terminal workflow run envelope.
        */
-      runFromTool: async (params) => connection.sendRequest("session.factory.runFromTool", { sessionId, ...params }),
+      runFromTool: async (params) => connection.sendRequest("session.workflow.runFromTool", { ...params, sessionId }),
       /**
-       * Internal tool-originated factory resume.
+       * Internal tool-originated dynamic workflow resume.
        *
-       * @param params Internal parameters for resuming a factory run from a tool.
+       * @param params Internal parameters for resuming a workflow run from a tool.
        *
-       * @returns Resolved persisted factory identity and resumed run envelope.
+       * @returns Resolved persisted workflow identity and resumed run envelope.
        */
-      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params }),
+      resumeFromTool: async (params) => connection.sendRequest("session.workflow.resumeFromTool", { ...params, sessionId }),
       /**
-       * Atomically pauses an owned factory attempt at a durable checkpoint.
+       * Atomically pauses an owned dynamic workflow attempt at a durable checkpoint.
        *
        * @param params Parameters for an owned durable pause checkpoint.
        */
-      pauseAtCheckpoint: async (params) => connection.sendRequest("session.factory.pauseAtCheckpoint", { sessionId, ...params })
+      pauseAtCheckpoint: async (params) => connection.sendRequest("session.workflow.pauseAtCheckpoint", { ...params, sessionId })
     },
     /** @experimental */
     model: {
@@ -2702,10 +3681,20 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns The model identifier active on the session after the switch.
        */
-      applyStartupOverlay: async (params) => connection.sendRequest("session.model.applyStartupOverlay", { sessionId, ...params })
+      applyStartupOverlay: async (params) => connection.sendRequest("session.model.applyStartupOverlay", { ...params, sessionId }),
+      /**
+       * Clears an unchanged startup model/provider seed before default-model resolution. Never clears a resumed or user-selected model.
+       */
+      clearStartupSeed: async (params) => connection.sendRequest("session.model.clearStartupSeed", { ...params, sessionId })
     },
     /** @experimental */
     mcp: {
+      /**
+       * Records the IDE the host is connected to, so the agent's system prompt can name it and its workspace folder. Null or an omitted `ide` clears the recorded value, which is how a host reports that it is disconnected; there is no separate clear method. Both `ideName` and `workspaceFolder` are required together, because half a state cannot be attributed to a project.
+       *
+       * @param params Records which IDE the host is connected to, or clears it.
+       */
+      setConnectedIdeInfo: async (params) => connection.sendRequest("session.mcp.setConnectedIdeInfo", { ...params, sessionId }),
       /**
        * Reloads MCP server connections for the session with an explicit host-provided configuration.
        *
@@ -2713,7 +3702,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns MCP server startup filtering result.
        */
-      reloadWithConfig: async (params) => connection.sendRequest("session.mcp.reloadWithConfig", { sessionId, ...params }),
+      reloadWithConfig: async (params) => connection.sendRequest("session.mcp.reloadWithConfig", { ...params, sessionId }),
       /**
        * Configures the built-in GitHub MCP server for the session's current auth context.
        *
@@ -2721,19 +3710,36 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Result of configuring GitHub MCP.
        */
-      configureGitHub: async (params) => connection.sendRequest("session.mcp.configureGitHub", { sessionId, ...params }),
+      configureGitHub: async (params) => connection.sendRequest("session.mcp.configureGitHub", { ...params, sessionId }),
       /**
        * 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 }),
+      registerExternalClient: async (params) => connection.sendRequest("session.mcp.registerExternalClient", { ...params, 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.
        *
        * @param params Server name identifying the external client to remove.
        */
-      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params })
+      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { ...params, sessionId })
+    },
+    /** @experimental */
+    connectors: {
+      /**
+       * Reconciles the authoritative Connector catalog into the session MCP projection during startup with a bounded deadline and fail-closed cleanup.
+       *
+       * @param params Pins a Connector operation to one host-owned GitHub account through its opaque selection ID. Provider tokens are never accepted.
+       *
+       * @returns Authoritative session connector state. Account IDs are opaque routing identifiers and credentials are never included.
+       */
+      reconcileForStartup: async (params) => connection.sendRequest("session.connectors.reconcileForStartup", { ...params, sessionId }),
+      /**
+       * Removes the runtime-owned Connector MCP projection without changing service-side connections.
+       *
+       * @returns Authoritative session connector state. Account IDs are opaque routing identifiers and credentials are never included.
+       */
+      withdrawProjection: async () => connection.sendRequest("session.connectors.withdrawProjection", { sessionId })
     },
     /** @experimental */
     commands: {
@@ -2744,7 +3750,34 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Whether finalizing the invocation effect succeeded, and the failure reason when it did not.
        */
-      finalizeInvocationEffect: async (params) => connection.sendRequest("session.commands.finalizeInvocationEffect", { sessionId, ...params })
+      finalizeInvocationEffect: async (params) => connection.sendRequest("session.commands.finalizeInvocationEffect", { ...params, sessionId })
+    },
+    /** @experimental */
+    ui: {
+      /**
+       * Resolves a pending elicitation request after direct interaction in the trusted in-process client. Only an accepted response to the built-in ask_user tool can become trusted human evidence.
+       *
+       * @param params Pending elicitation request ID and the user's response (accept/decline/cancel + form values).
+       *
+       * @returns Indicates whether the elicitation response was accepted; false if it was already resolved by another client.
+       */
+      handleHumanAskUser: async (params) => connection.sendRequest("session.ui.handleHumanAskUser", { ...params, sessionId }),
+      /**
+       * Resolves a pending `user_input.requested` event after direct interaction in the trusted in-process client.
+       *
+       * @param params Request ID of a pending `user_input.requested` event and the user's response.
+       *
+       * @returns Indicates whether the pending UI request was resolved by this call.
+       */
+      handleHumanUserInput: async (params) => connection.sendRequest("session.ui.handleHumanUserInput", { ...params, sessionId }),
+      /**
+       * Resolves a pending `exit_plan_mode.requested` event after direct interaction in the trusted in-process client.
+       *
+       * @param params Request ID of a pending `exit_plan_mode.requested` event and the user's response.
+       *
+       * @returns Indicates whether the pending UI request was resolved by this call.
+       */
+      handleHumanExitPlanMode: async (params) => connection.sendRequest("session.ui.handleHumanExitPlanMode", { ...params, sessionId })
     },
     /** @experimental */
     settings: {
@@ -2761,7 +3794,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Result of evaluating a Rust-owned settings predicate.
        */
-      evaluatePredicate: async (params) => connection.sendRequest("session.settings.evaluatePredicate", { sessionId, ...params })
+      evaluatePredicate: async (params) => connection.sendRequest("session.settings.evaluatePredicate", { ...params, sessionId })
     },
     /** @experimental */
     queue: {
@@ -2784,7 +3817,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Whether a deferred-idle drain should run.
        */
-      beginDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.beginDeferredIdleDrain", { sessionId, ...params }),
+      beginDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.beginDeferredIdleDrain", { ...params, sessionId }),
       /**
        * Finishes a native deferred-idle drain and reports whether to drain queue work or emit idle.
        *
@@ -2792,13 +3825,13 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Action selected by the native deferred-idle drain.
        */
-      finishDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.finishDeferredIdleDrain", { sessionId, ...params }),
+      finishDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.finishDeferredIdleDrain", { ...params, sessionId }),
       /**
        * 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 }),
+      deferSessionIdle: async (params) => connection.sendRequest("session.queue.deferSessionIdle", { ...params, sessionId }),
       /**
        * Consumes queued native system notifications matching an internal filter.
        *
@@ -2806,7 +3839,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Indicates whether a user-facing pending item was removed.
        */
-      consumeSystemNotifications: async (params) => connection.sendRequest("session.queue.consumeSystemNotifications", { sessionId, ...params }),
+      consumeSystemNotifications: async (params) => connection.sendRequest("session.queue.consumeSystemNotifications", { ...params, sessionId }),
       /**
        * Enqueues the internal resume-pending wake item when orphan handling needs a follow-up turn.
        *
@@ -2819,6 +3852,15 @@ function createInternalSessionRpc(connection, sessionId) {
       process: async () => connection.sendRequest("session.queue.process", { sessionId })
     },
     /** @experimental */
+    usage: {
+      /**
+       * Internal host-only replacement of absolute code-change totals reported by a relay host.
+       *
+       * @param params Internal absolute code-change totals reported by the owning host.
+       */
+      setCodeChanges: async (params) => connection.sendRequest("session.usage.setCodeChanges", { ...params, sessionId })
+    },
+    /** @experimental */
     schedule: {
       /**
        * Hydrates the native schedule registry from persisted session events.
@@ -2837,7 +3879,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Result of registering or re-arming a scheduled prompt.
        */
-      add: async (params) => connection.sendRequest("session.schedule.add", { sessionId, ...params }),
+      add: async (params) => connection.sendRequest("session.schedule.add", { ...params, sessionId }),
       /**
        * Registers a recurring cron scheduled prompt.
        *
@@ -2845,7 +3887,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Result of registering or re-arming a scheduled prompt.
        */
-      addCron: async (params) => connection.sendRequest("session.schedule.addCron", { sessionId, ...params }),
+      addCron: async (params) => connection.sendRequest("session.schedule.addCron", { ...params, sessionId }),
       /**
        * Registers an absolute-time scheduled prompt.
        *
@@ -2853,7 +3895,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Result of registering or re-arming a scheduled prompt.
        */
-      addAt: async (params) => connection.sendRequest("session.schedule.addAt", { sessionId, ...params }),
+      addAt: async (params) => connection.sendRequest("session.schedule.addAt", { ...params, sessionId }),
       /**
        * Registers a self-paced scheduled prompt.
        *
@@ -2861,7 +3903,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Result of registering or re-arming a scheduled prompt.
        */
-      addSelfPaced: async (params) => connection.sendRequest("session.schedule.addSelfPaced", { sessionId, ...params }),
+      addSelfPaced: async (params) => connection.sendRequest("session.schedule.addSelfPaced", { ...params, sessionId }),
       /**
        * Re-arms an active self-paced scheduled prompt.
        *
@@ -2869,7 +3911,7 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Result of registering or re-arming a scheduled prompt.
        */
-      rearmSelfPaced: async (params) => connection.sendRequest("session.schedule.rearmSelfPaced", { sessionId, ...params })
+      rearmSelfPaced: async (params) => connection.sendRequest("session.schedule.rearmSelfPaced", { ...params, sessionId })
     }
   };
 }
@@ -2879,14 +3921,14 @@ 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}`);
+  connection.onRequest("workflow.execute", async (params) => {
+    const handler = getHandlers(params.sessionId).workflow;
+    if (!handler) throw new Error(`No workflow 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}`);
+  connection.onRequest("workflow.abort", async (params) => {
+    const handler = getHandlers(params.sessionId).workflow;
+    if (!handler) throw new Error(`No workflow handler registered for session: ${params.sessionId}`);
     return handler.abort(params);
   });
   connection.onRequest("tasks.cancel", async (params) => {
@@ -2899,11 +3941,21 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
     return handler.readFile(params);
   });
+  connection.onRequest("sessionFs.readFileBytes", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.readFileBytes(params);
+  });
   connection.onRequest("sessionFs.writeFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
     return handler.writeFile(params);
   });
+  connection.onRequest("sessionFs.writeFileBytes", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    return handler.writeFileBytes(params);
+  });
   connection.onRequest("sessionFs.appendFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
@@ -2976,6 +4028,11 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
   });
 }
 function registerClientGlobalApiHandlers(connection, handlers) {
+  connection.onNotification("host.exited", async (params) => {
+    const handler = handlers.host;
+    if (!handler) return;
+    await handler.exited(params);
+  });
   connection.onRequest("extensionLaunchProvider.resolve", async (params) => {
     const handler = handlers.extensionLaunchProvider;
     if (!handler) throw new Error("No extensionLaunchProvider client-global handler registered");
@@ -3001,6 +4058,11 @@ function registerClientGlobalApiHandlers(connection, handlers) {
     if (!handler) throw new Error("No gitHubToken client-global handler registered");
     return handler.getToken(params);
   });
+  connection.onRequest("installations.confirm", async (params) => {
+    const handler = handlers.installations;
+    if (!handler) throw new Error("No installations client-global handler registered");
+    return handler.confirm(params);
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {