@github/copilot-sdk 1.0.13-preview.4 → 1.0.13

package/README.md

@@ -8,6 +8,20 @@ To use the SDK, you'll need:
 
 - Node.js ^20.19.0 or >=22.12.0
 
+The SDK uses an optional `@github/copilot-sdk-<platform>` package containing the
+Copilot CLI runtime for the host platform. These packages are built from
+verified `github/copilot-cli` release assets when the SDK is published, so
+starting the SDK performs no runtime download. Set `COPILOT_CLI_PATH` to use an
+existing installation instead.
+
+The checked-in release pin is `copilotCliVersion` in `package.json`. Run
+`npm run set:cli-version -- <version>` to update it and regenerate the compiled
+metadata in `src/cliVersion.ts`. Packaging verifies release assets against the
+release's `SHA256SUMS.txt`.
+
+`npm run pack:release` builds the main package and all platform packages. Set
+`COPILOT_CLI_DOWNLOAD_BASE_URL` to use a release mirror while packaging.
+
 ## Installation
 
 ```bash
@@ -22,6 +36,7 @@ Try the interactive chat sample (from the repo root):
 cd nodejs
 npm ci
 npm run build
+export COPILOT_CLI_PATH="$(npm run --silent prepare:runtime -- --print-path)"
 cd samples
 npm install
 npm start
@@ -132,6 +147,7 @@ Create a new conversation session.
 
 - `sessionId?: string` - Custom session ID.
 - `model?: string` - Model to use ("gpt-5", "claude-sonnet-4.5", etc.). **Required when using custom provider.**
+- `capi?: CapiSessionOptions` - Copilot API options. With `model: "auto"`, set `autoTier` to `"efficiency"`, `"balance"`, or `"intelligence"` to choose a routing preference. Requires a runtime with Auto tier support and V2 Auto routing. Omission preserves default behavior. See [Auto tier persistence](../docs/features/session-persistence.md#auto-tier-persistence) for resume semantics.
 - `reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max"` - Reasoning effort level for models that support it. Use `listModels()` to check which models support this option.
 - `tools?: Tool[]` - Custom tools exposed to the CLI. Tools without `handler` are declaration-only and must be resolved via pending tool-call RPCs.
 - `systemMessage?: SystemMessageConfig` - System message customization (see below)
@@ -303,6 +319,32 @@ const unsubscribe = session.on((event) => {
 unsubscribe();
 ```
 
+##### `setModel(model: string, options?): Promise<void>`
+
+Change the model for this session. The new model takes effect for the next message; conversation history is preserved.
+
+**Options:**
+
+- `reasoningEffort?: string` - Reasoning effort level
+- `autoTier?: AutoTier | null` - Auto routing preference to stage together with selecting `auto`. Pass `null` to return to the provider's default Auto routing; omit it to leave the current preference unchanged.
+
+##### `setAutoTier(autoTier: AutoTier | null): Promise<ModelSwitchAutoTierResult>`
+
+Change the Auto routing preference without changing the selected model. Pass `null` to return to the provider's default Auto routing.
+
+The runtime does not apply the preference immediately. It records the request and commits it only when a later user turn using the `auto` model successfully obtains a usable model from the provider, so a `pending` status confirms acceptance rather than effect. Only the most recent request survives.
+
+Watch for the outcome through the `session.model_change` event on success or the ephemeral `session.auto_tier_switch_failed` event on failure, and read the authoritative state at any time with `session.rpc.model.getCurrent()`.
+
+```typescript
+const result = await session.setAutoTier("intelligence");
+if (result.status === "pending") {
+    // Accepted, but not yet in effect.
+}
+```
+
+See [Auto tier persistence](../docs/features/session-persistence.md#auto-tier-persistence) for the full lifecycle rules.
+
 ##### `abort(): Promise<void>`
 
 Abort the currently processing message in this session.
@@ -935,15 +977,15 @@ const session = await client.createSession({
 
 The handler must return one of the `PermissionDecision` shapes (or `{ kind: "no-result" }`). Approval scopes are present-tense — they describe the decision to apply, not the outcome reported back on session events:
 
-| Kind                     | Meaning                                                                                      | Extra fields                                                            |
-| ------------------------ | -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| `"approve-once"`         | Allow this single request                                                                    | —                                                                       |
-| `"approve-for-session"`  | Allow this request and remember the approval for the rest of the session                     | `approval?` (rule to remember), `domain?` (for URL approvals)           |
-| `"approve-for-location"` | Allow this request and persist the approval for this project location (git root or cwd)      | `approval` (rule to persist), `locationKey` (location to persist under) |
-| `"approve-permanently"`  | Allow this request and persist the approval across sessions (currently used for URL domains) | `domain` (URL domain to approve)                                        |
-| `"reject"`               | Deny the request                                                                             | `feedback?` (optional string surfaced to the agent)                     |
-| `"user-not-available"`   | Deny the request because no user is available to confirm it                                  | —                                                                       |
-| `"no-result"`            | Suppress this SDK client's response so another connected client can answer the pending request | —                                                                     |
+| Kind                     | Meaning                                                                                        | Extra fields                                                            |
+| ------------------------ | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
+| `"approve-once"`         | Allow this single request                                                                      | —                                                                       |
+| `"approve-for-session"`  | Allow this request and remember the approval for the rest of the session                       | `approval?` (rule to remember), `domain?` (for URL approvals)           |
+| `"approve-for-location"` | Allow this request and persist the approval for this project location (git root or cwd)        | `approval` (rule to persist), `locationKey` (location to persist under) |
+| `"approve-permanently"`  | Allow this request and persist the approval across sessions (currently used for URL domains)   | `domain` (URL domain to approve)                                        |
+| `"reject"`               | Deny the request                                                                               | `feedback?` (optional string surfaced to the agent)                     |
+| `"user-not-available"`   | Deny the request because no user is available to confirm it                                    | —                                                                       |
+| `"no-result"`            | Suppress this SDK client's response so another connected client can answer the pending request | —                                                                       |
 
 ### Resuming Sessions
 

package/dist/cjs/cliVersion.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cliVersion_exports = {};
+__export(cliVersion_exports, {
+  COPILOT_CLI_USE_NPM_PACKAGE: () => COPILOT_CLI_USE_NPM_PACKAGE,
+  COPILOT_CLI_VERSION: () => COPILOT_CLI_VERSION
+});
+module.exports = __toCommonJS(cliVersion_exports);
+const COPILOT_CLI_VERSION = "1.0.83";
+const COPILOT_CLI_USE_NPM_PACKAGE = false;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COPILOT_CLI_USE_NPM_PACKAGE,
+  COPILOT_CLI_VERSION
+});

package/dist/cjs/client.js

@@ -34,21 +34,19 @@ module.exports = __toCommonJS(client_exports);
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
-var import_node_module = require("node:module");
 var import_node_net = require("node:net");
 var import_node_path = require("node:path");
-var import_node_url = require("node:url");
 var import_node = require("vscode-jsonrpc/node.js");
 var import_rpc = require("./generated/rpc.js");
 var import_sdkProtocolVersion = require("./sdkProtocolVersion.js");
 var import_session = require("./session.js");
 var import_runtimeArtifacts = require("./runtimeArtifacts.js");
+var import_cliVersion = require("./cliVersion.js");
 var import_sessionFsProvider = require("./sessionFsProvider.js");
 var import_copilotRequestHandler = require("./copilotRequestHandler.js");
 var import_telemetry = require("./telemetry.js");
 var import_toolSet = require("./toolSet.js");
 var import_types = require("./types.js");
-const import_meta = {};
 const MIN_PROTOCOL_VERSION = 3;
 const RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
 function isZodSchema(value) {
@@ -151,6 +149,15 @@ function toWireCustomAgents(agents) {
     return { ...rest, mcpServers: toWireMcpServers(mcpServers) };
   });
 }
+function clientInfoToWire(info) {
+  if (info == null) return void 0;
+  const wire = {};
+  if (info.applicationName) wire.editorName = info.applicationName;
+  if (info.applicationVersion) wire.editorVersion = info.applicationVersion;
+  if (info.integrationName) wire.extensionName = info.integrationName;
+  if (info.integrationVersion) wire.extensionVersion = info.integrationVersion;
+  return Object.keys(wire).length > 0 ? wire : void 0;
+}
 function toWireLargeOutput(config) {
   if (!config) return void 0;
   const { outputDirectory, ...rest } = config;
@@ -208,53 +215,8 @@ function getNodeExecPath() {
   }
   return process.execPath;
 }
-function getCliPlatformPackageNames() {
-  const arch = process.arch;
-  const variants = process.platform === "linux" ? ["linux", "linuxmusl"] : [process.platform];
-  return variants.map((variant) => `@github/copilot-${variant}-${arch}`);
-}
-function getBundledCliPackage() {
-  const packageNames = getCliPlatformPackageNames();
-  if (typeof import_meta.resolve === "function") {
-    for (const packageName of packageNames) {
-      try {
-        const packageEntryUrl = import_meta.resolve(packageName);
-        const packageEntryPath = (0, import_node_url.fileURLToPath)(packageEntryUrl);
-        return {
-          root: (0, import_node_path.dirname)(packageEntryPath),
-          platform: packageName.slice("@github/copilot-".length)
-        };
-      } catch {
-      }
-    }
-    throw new Error(
-      `Could not resolve a @github/copilot platform package (tried ${packageNames.join(", ")}). Ensure @github/copilot is installed, or pass cliPath/cliUrl to CopilotClient.`
-    );
-  }
-  const req = (0, import_node_module.createRequire)(__filename);
-  const searchPaths = req.resolve.paths("@github/copilot") ?? [];
-  for (const base of searchPaths) {
-    for (const packageName of packageNames) {
-      const root = (0, import_node_path.join)(base, ...packageName.split("/"));
-      const candidate = (0, import_node_path.join)(root, "index.js");
-      if ((0, import_node_fs.existsSync)(candidate)) {
-        return {
-          root,
-          platform: packageName.slice("@github/copilot-".length)
-        };
-      }
-    }
-  }
-  throw new Error(
-    `Could not find a @github/copilot platform package (tried ${packageNames.join(", ")}). Searched ${searchPaths.length} paths. Ensure @github/copilot is installed, or pass cliPath/cliUrl to CopilotClient.`
-  );
-}
 function getBundledRuntimePath() {
-  const bundled = getBundledCliPackage();
-  return (0, import_runtimeArtifacts.materializeRuntimeBundle)({
-    packageRoot: bundled.root,
-    platform: bundled.platform
-  });
+  return (0, import_runtimeArtifacts.ensureRuntimeBundle)(import_cliVersion.COPILOT_CLI_VERSION);
 }
 class TeardownResilientStreamMessageWriter extends import_node.StreamMessageWriter {
   suppressWriteErrors = false;
@@ -274,6 +236,7 @@ class CopilotClient {
   ffiHost = null;
   connection = null;
   messageWriter = null;
+  connectionClosed = false;
   socket = null;
   runtimePort = null;
   actualHost = "localhost";
@@ -473,8 +436,6 @@ class CopilotClient {
       const explicitCliPath = conn.path ?? effectiveEnv.COPILOT_CLI_PATH;
       if (explicitCliPath) {
         this.resolvedCliPath = explicitCliPath;
-      } else {
-        this.resolvedCliPath = getBundledRuntimePath();
       }
     }
     const connArgs = conn.kind === "stdio" || conn.kind === "tcp" ? conn.args ?? [] : [];
@@ -489,7 +450,8 @@ class CopilotClient {
       baseDirectory: options.baseDirectory,
       sessionIdleTimeoutSeconds: options.sessionIdleTimeoutSeconds ?? 0,
       enableRemoteSessions: options.enableRemoteSessions ?? false,
-      mode: options.mode ?? "copilot-cli"
+      mode: options.mode ?? "copilot-cli",
+      clientInfo: options.clientInfo
     };
     if (this.options.mode === "empty") {
       const hasPersistence = this.options.baseDirectory !== void 0 || this.sessionFsConfig !== null || // External runtimes manage their own persistence layer; the SDK
@@ -505,17 +467,29 @@ class CopilotClient {
   connectionExtraArgs = [];
   /**
    * Parse CLI URL into host and port
-   * Supports formats: "host:port", "http://host:port", "https://host:port", or just "port"
+   * Supports formats: "host:port", "[ipv6]:port", "http://host:port", "https://host:port", or just "port"
    */
   parseCliUrl(url) {
-    let cleanUrl = url.replace(/^https?:\/\//, "");
+    const cleanUrl = url.replace(/^https?:\/\//, "");
     if (/^\d+$/.test(cleanUrl)) {
       return { host: "localhost", port: parseInt(cleanUrl, 10) };
     }
+    const ipv6Match = cleanUrl.match(/^\[([^\]]+)\]:(\d+)$/);
+    if (ipv6Match) {
+      const host2 = ipv6Match[1];
+      if (!(0, import_node_net.isIPv6)(host2)) {
+        throw new Error(`Invalid cliUrl format: ${url}`);
+      }
+      const port2 = parseInt(ipv6Match[2], 10);
+      if (isNaN(port2) || port2 <= 0 || port2 > 65535) {
+        throw new Error(`Invalid port in cliUrl: ${url}`);
+      }
+      return { host: host2, port: port2 };
+    }
     const parts = cleanUrl.split(":");
     if (parts.length !== 2) {
       throw new Error(
-        `Invalid cliUrl format: ${url}. Expected "host:port", "http://host:port", or "port"`
+        `Invalid cliUrl format: ${url}. Expected "host:port", "[ipv6]:port", "http://host:port", or "port"`
       );
     }
     const host = parts[0] || "localhost";
@@ -645,6 +619,7 @@ class CopilotClient {
       return;
     }
     this.forceStopping = false;
+    this.connectionClosed = false;
     this.processTransportError = null;
     this.state = "connecting";
     try {
@@ -743,7 +718,7 @@ class CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
-    if (this.connection && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
+    if (this.connection && !this.connectionClosed && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
       void shutdownPromise.catch(() => void 0);
@@ -1274,6 +1249,7 @@ class CopilotClient {
         gitHubTokenProviderRegistrationId,
         remoteSession: config.remoteSession,
         cloud: config.cloud,
+        featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
         managedSettings: config.managedSettings
@@ -1307,6 +1283,7 @@ class CopilotClient {
       await this.updateSessionOptionsForMode(session, config);
       this.commitGitHubTokenProvider(returnedSessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
+      session?._markDisconnected();
       if (registeredId !== void 0) {
         this.sessions.delete(registeredId);
       }
@@ -1509,6 +1486,7 @@ class CopilotClient {
         gitHubTokenProviderRegistrationId,
         remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
+        featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
         managedSettings: config.managedSettings,
@@ -1538,6 +1516,7 @@ class CopilotClient {
       await this.updateSessionOptionsForMode(session, config);
       this.commitGitHubTokenProvider(sessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
+      session._markDisconnected();
       this.sessions.delete(sessionId);
       if (gitHubTokenProviderRegistrationId !== void 0) {
         this.githubTokenProviders.delete(gitHubTokenProviderRegistrationId);
@@ -1653,10 +1632,17 @@ class CopilotClient {
     const raceAgainstExit = (p) => this.processExitPromise ? Promise.race([p, this.processExitPromise]) : p;
     let serverVersion;
     try {
-      const connectParams = { token: this.effectiveConnectionToken };
+      const connectParams = {
+        token: this.effectiveConnectionToken,
+        supportedTaskKinds: ["agent", "client", "shell"]
+      };
       if (this.onGitHubTelemetry != null) {
         connectParams.enableGitHubTelemetryForwarding = true;
       }
+      const clientInfo = clientInfoToWire(this.options.clientInfo);
+      if (clientInfo != null) {
+        connectParams.clientInfo = clientInfo;
+      }
       const result = await raceAgainstExit(this.internalRpc.connect(connectParams));
       serverVersion = result.protocolVersion;
     } catch (err) {
@@ -1917,6 +1903,7 @@ class CopilotClient {
    * Start the CLI server process
    */
   async startCLIServer() {
+    this.resolvedCliPath ??= await getBundledRuntimePath();
     return new Promise((resolve2, reject) => {
       this.stderrBuffer = "";
       const args = [...this.connectionExtraArgs, "--headless", "--no-auto-update"];
@@ -1954,7 +1941,7 @@ class CopilotClient {
       }
       if (!(0, import_node_fs.existsSync)(this.resolvedCliPath)) {
         throw new Error(
-          `Copilot CLI not found at ${this.resolvedCliPath}. Ensure @github/copilot is installed.`
+          `Copilot CLI not found at ${this.resolvedCliPath}. Set COPILOT_CLI_PATH to use a custom installation.`
         );
       }
       const stdioConfig = this.connectionConfig.kind === "stdio" ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"];
@@ -2081,12 +2068,19 @@ stderr: ${stderrOutput}`
   /** Starts the in-process FFI runtime with SDK-managed typed options. */
   async startInProcessFfi() {
     const explicitEntrypoint = this.resolvedEnv.COPILOT_CLI_PATH;
-    const runtimeLibrary = explicitEntrypoint ? (0, import_node_path.join)(
-      (0, import_node_path.dirname)((0, import_node_path.resolve)(explicitEntrypoint)),
-      "prebuilds",
-      CopilotClient.getNapiPrebuildsFolder(explicitEntrypoint),
-      "runtime.node"
-    ) : (0, import_node_path.join)((0, import_node_path.dirname)(getBundledRuntimePath()), "runtime.node");
+    let runtimeLibrary;
+    if (explicitEntrypoint) {
+      const entrypointDirectory = (0, import_node_path.dirname)((0, import_node_path.resolve)(explicitEntrypoint));
+      const adjacentRuntime = (0, import_node_path.join)(entrypointDirectory, "runtime.node");
+      runtimeLibrary = (0, import_node_fs.existsSync)(adjacentRuntime) ? adjacentRuntime : (0, import_node_path.join)(
+        entrypointDirectory,
+        "prebuilds",
+        CopilotClient.getNapiPrebuildsFolder(explicitEntrypoint),
+        "runtime.node"
+      );
+    } else {
+      runtimeLibrary = (0, import_node_path.join)((0, import_node_path.dirname)(await getBundledRuntimePath()), "runtime.node");
+    }
     const { FfiRuntimeHost } = await import("./ffiRuntimeHost.js");
     const environment = {};
     if (this.options.gitHubToken) {
@@ -2272,12 +2266,24 @@ stderr: ${stderrOutput}` : ""}`
         return await this.handleHooksInvoke(params);
       }
     );
-    this.connection.onClose(() => {
+    const connection = this.connection;
+    const markDisconnected = () => {
+      if (this.connection !== connection) {
+        return;
+      }
+      this.connectionClosed = true;
       this.state = "disconnected";
+      for (const session of this.sessions.values()) {
+        session._markDisconnected();
+      }
+      this.sessions.clear();
       this.githubTokenProviders.clear();
-    });
-    this.connection.onError((_error) => {
-      this.state = "disconnected";
+    };
+    this.connection.onClose(markDisconnected);
+    this.connection.onError(() => {
+      if (this.connection === connection) {
+        this.state = "disconnected";
+      }
     });
   }
   handleSessionEventNotification(notification) {

package/dist/cjs/generated/rpc.js

@@ -39,6 +39,17 @@ function createServerRpc(connection) {
      */
     ping: async (params) => connection.sendRequest("ping", params),
     /** @experimental */
+    hooks: {
+      /**
+       * Discovers hook actions enabled under server-side discovery settings from user, repository, plugin, and managed-policy sources.
+       *
+       * @param params Optional project paths and host-exclusion behavior for server-scoped hook discovery.
+       *
+       * @returns Server-discovered hook actions and partial-load diagnostics from user, repository, plugin, and managed-policy sources. Concrete sessions may include additional session-specific hook sources.
+       */
+      discover: async (params) => connection.sendRequest("hooks.discover", params)
+    },
+    /** @experimental */
     models: {
       /**
        * Lists Copilot models available to the authenticated user.
@@ -427,7 +438,11 @@ function createServerRpc(connection) {
        *
        * @returns Validated device-managed settings discovered before a session exists.
        */
-      read: async () => connection.sendRequest("managedSettings.read", {})
+      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.
+       */
+      clearCache: async () => connection.sendRequest("managedSettings.clearCache", {})
     },
     /** @experimental */
     runtime: {
@@ -506,6 +521,14 @@ function createServerRpc(connection) {
        * @returns Sessions matching the filter, ordered most-recently-modified first.
        */
       list: async (params) => connection.sendRequest("sessions.list", params),
+      /**
+       * Reads a page of durable events directly from a local session's persisted journal without creating, resuming, or activating the session. The initial backward read uses a bounded tail scan for fast first paint; cursor continuations preserve the session event-log paging semantics. Persisted events may omit payloads that are reconstructed only for an active session.
+       *
+       * @param params Pagination options for reading an inactive or active local session's persisted event journal.
+       *
+       * @returns Batch of session events returned by a read, with cursor and continuation metadata.
+       */
+      readPersistedEvents: async (params) => connection.sendRequest("sessions.readPersistedEvents", params),
       /**
        * Finds the local session bound to a GitHub task ID, if any.
        *
@@ -983,9 +1006,9 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     model: {
       /**
-       * Gets the currently selected model for the session.
+       * Gets the session's authoritative model snapshot, including the committed Auto preference and any newer unclaimed Auto preference waiting for a future user turn.
        *
-       * @returns The currently selected model, reasoning effort, and context tier for the session. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.
+       * @returns The session's authoritative model snapshot. Auto preference fields are configuration for the virtual `auto` model and do not change the selected model identifier. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.
        */
       getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
       /**
@@ -996,6 +1019,14 @@ 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 }),
+      /**
+       * 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`.
+       *
+       * @param params An Auto preference request for the session. This updates Auto configuration only; it does not change the selected model to `auto`.
+       *
+       * @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 }),
       /**
        * Updates the session's reasoning effort without changing the selected model.
        *
@@ -1202,6 +1233,15 @@ function createSessionRpc(connection, sessionId) {
       diff: async (params) => connection.sendRequest("session.workspaces.diff", { sessionId, ...params })
     },
     /** @experimental */
+    autopilotObjective: {
+      /**
+       * Reads the current canonical autopilot objective state for this session.
+       *
+       * @returns Canonical runtime state for the session's current autopilot objective.
+       */
+      getState: async () => connection.sendRequest("session.autopilotObjective.getState", { sessionId })
+    },
+    /** @experimental */
     completions: {
       /**
        * Gets the characters that should trigger host-driven completions for the session. Empty disables host-driven completions (e.g. local sessions, or a relay host that does not advertise them).
@@ -1295,6 +1335,22 @@ function createSessionRpc(connection, sessionId) {
        * @returns Background tasks currently tracked by the session.
        */
       list: async () => connection.sendRequest("session.tasks.list", { sessionId }),
+      /**
+       * Registers a client-owned task, or reclaims an orphaned task belonging to the same extension principal.
+       *
+       * @param params Registers or reclaims a client-owned task.
+       *
+       * @returns Result of registering or reclaiming a client-owned task.
+       */
+      register: async (params) => connection.sendRequest("session.tasks.register", { sessionId, ...params }),
+      /**
+       * Publishes generic progress or a terminal outcome for a client-owned task.
+       *
+       * @param params Updates a client-owned task.
+       *
+       * @returns Result of publishing a client-owned task update.
+       */
+      update: async (params) => connection.sendRequest("session.tasks.update", { sessionId, ...params }),
       /**
        * Refreshes metadata for any detached background shells the runtime knows about.
        *
@@ -2763,6 +2819,11 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
     return handler.abort(params);
   });
+  connection.onRequest("tasks.cancel", async (params) => {
+    const handler = getHandlers(params.sessionId).tasks;
+    if (!handler) throw new Error(`No tasks handler registered for session: ${params.sessionId}`);
+    return handler.cancel(params);
+  });
   connection.onRequest("sessionFs.readFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);