@github/copilot-language-server 1.543.0 → 1.544.0

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

@@ -42,6 +42,7 @@ async function joinSession(config = {}) {
   const {
     extensionSdkPath: _stripped,
     factories,
+    requestedEnvironmentVariables,
     ...rest
   } = config;
   void _stripped;
@@ -52,7 +53,8 @@ async function joinSession(config = {}) {
       onPermissionRequest: config.onPermissionRequest ?? import_types.defaultJoinSessionPermissionHandler,
       suppressResumeEvent: config.suppressResumeEvent ?? true
     },
-    factories
+    factories,
+    requestedEnvironmentVariables?.length ? { requestedEnvironmentVariables } : void 0
   );
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -85,7 +85,7 @@ function loadLibrary(libraryPath) {
   return loadedLibrary;
 }
 function buildArgvJson(cliEntrypoint, args) {
-  const argv = cliEntrypoint.toLowerCase().endsWith(".js") ? ["node", cliEntrypoint, "--embedded-host", "--no-auto-update"] : [cliEntrypoint, "--embedded-host", "--no-auto-update"];
+  const argv = cliEntrypoint ? cliEntrypoint.toLowerCase().endsWith(".js") ? ["node", cliEntrypoint, "--embedded-host", "--no-auto-update"] : [cliEntrypoint, "--embedded-host", "--no-auto-update"] : [];
   argv.push(...args);
   return Buffer.from(JSON.stringify(argv), "utf8");
 }
@@ -140,24 +140,21 @@ class FfiRuntimeHost {
   /** The stream JSON-RPC writes client→server frames to. */
   sendStream;
   /**
-   * Resolves the cdylib next to the given CLI entrypoint and prepares the FFI host.
-   * The cdylib is resolved as `prebuilds/<prebuildsFolder>/runtime.node` relative to
-   * the entrypoint directory (the napi-rs `<node-platform>-<arch>` layout, e.g.
-   * `linux-x64`). Throws if it cannot be found.
+   * Loads the runtime cdylib at the given path and prepares the FFI host.
    */
-  static create(cliEntrypoint, prebuildsFolder, environment, args) {
-    const fullEntrypoint = (0, import_node_path.resolve)(cliEntrypoint);
-    const distDir = (0, import_node_path.dirname)(fullEntrypoint);
-    const libraryPath = (0, import_node_path.join)(distDir, "prebuilds", prebuildsFolder, "runtime.node");
-    if (!(0, import_node_fs.existsSync)(libraryPath)) {
-      throw new Error(`FFI runtime library not found. Looked for '${libraryPath}'.`);
+  static create(libraryPath, cliEntrypoint, environment, args) {
+    const fullLibraryPath = (0, import_node_path.resolve)(libraryPath);
+    if (!(0, import_node_fs.existsSync)(fullLibraryPath)) {
+      throw new Error(`FFI runtime library not found at '${fullLibraryPath}'.`);
     }
-    return new FfiRuntimeHost(libraryPath, fullEntrypoint, environment, args);
+    return new FfiRuntimeHost(
+      fullLibraryPath,
+      cliEntrypoint ? (0, import_node_path.resolve)(cliEntrypoint) : void 0,
+      environment,
+      args
+    );
   }
-  /**
-   * Starts the in-process runtime: spawns the CLI worker via the native host,
-   * waits for readiness, and opens the FFI JSON-RPC connection.
-   */
+  /** Starts the in-process Rust runtime and opens the FFI JSON-RPC connection. */
   async start() {
     const argvJson = buildArgvJson(this.cliEntrypoint, this.args);
     const envJson = buildEnvJson(this.environment);
@@ -177,9 +174,7 @@ class FfiRuntimeHost {
       );
     });
     if (!this.serverId) {
-      throw new Error(
-        `copilot_runtime_host_start failed (library '${this.libraryPath}', entrypoint '${this.cliEntrypoint}').`
-      );
+      throw new Error(`copilot_runtime_host_start failed (library '${this.libraryPath}').`);
     }
     this.outboundCallback = import_koffi.default.register(
       (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),

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

@@ -39,11 +39,22 @@ 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.
        *
-       * @param params Optional GitHub token used to list models for a specific user instead of the global auth context.
+       * @param params Optional opaque account selection or compatibility GitHub token used to list models.
        *
        * @returns List of Copilot models available to the resolved user, including capabilities and billing metadata.
        */
@@ -69,9 +80,9 @@ function createServerRpc(connection) {
     /** @experimental */
     account: {
       /**
-       * Gets Copilot quota usage for the authenticated user or supplied GitHub token.
+       * Gets Copilot quota usage for the current or opaquely selected authenticated user.
        *
-       * @param params Optional GitHub token used to look up quota for a specific user instead of the global auth context.
+       * @param params Optional opaque account selection or compatibility GitHub token used to look up quota.
        *
        * @returns Quota usage snapshots for the resolved user, keyed by quota type.
        */
@@ -89,9 +100,9 @@ function createServerRpc(connection) {
        */
       getAllUsers: async () => connection.sendRequest("account.getAllUsers", {}),
       /**
-       * Stores authentication credentials after successful login (e.g., device code flow).
+       * Validates and stores authentication credentials. When login is omitted, resolves the authenticated user from the token before persistence.
        *
-       * @param params Credentials to store after successful authentication
+       * @param params Credentials to validate and store. Omit login to resolve the authenticated user from the token.
        *
        * @returns Result of a successful login; throws on failure
        */
@@ -168,7 +179,15 @@ function createServerRpc(connection) {
        *
        * @returns MCP servers discovered from user, workspace, plugin, and built-in sources.
        */
-      discover: async (params) => connection.sendRequest("mcp.discover", params)
+      discover: async (params) => connection.sendRequest("mcp.discover", params),
+      /**
+       * Requests a side-effect-free MCP install plan from a catalog candidate handle or a caller-supplied card. This host-implemented server method is available through SDK/TUI hosts; standalone and C-ABI runtimes whose host does not implement server-method dispatch return JSON-RPC MethodNotFound. A runtime with planning available returns a normalised plan and opaque single-use plan handle; a runtime without it returns the typed planning-unavailable result. A completed plan reports resource identity, provenance, eligible transport choices, the user-scope target, required typed values and secret placeholders, the policy result, the configuration changes installing would make, and whether a reload would be needed. Planning never writes configuration, stores a secret, or reloads MCP servers, so abandoning a plan needs no call and leaves nothing behind.
+       *
+       * @param params A side-effect-free request for an MCP install plan. Computing a plan never writes configuration, stores a secret, or reloads MCP servers.
+       *
+       * @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)
     },
     /** @experimental */
     extensions: {
@@ -192,12 +211,23 @@ function createServerRpc(connection) {
       disable: async (params) => connection.sendRequest("extensions.disable", params)
     },
     /**
-     * Registers the calling SDK client as the per-entrypoint extension launch provider. Call before creating any sessions. When omitted, the runtime temporarily falls back to its built-in Node launcher for backward compatibility.
+     * 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.
      *
      * @experimental
      */
     registerExtensionLaunchProvider: async () => connection.sendRequest("registerExtensionLaunchProvider", {}),
     /** @experimental */
+    catalog: {
+      /**
+       * Requests a bounded catalog search. This host-implemented server method is available through SDK/TUI hosts; standalone and C-ABI runtimes whose host does not implement server-method dispatch return JSON-RPC MethodNotFound. A runtime with search available returns inert candidate summaries, each with an opaque single-use handle scoped to this runtime instance; a runtime without it returns the typed search-unavailable result. Public authorities may be searched anonymously, while an authority that requires credentials yields the typed authentication-required result. All returned text, URLs, and package metadata are untrusted external data and can never trigger instructions, tools, or installation. Read-only: nothing is installed, configured, or persisted.
+       *
+       * @param params A bounded catalog search. Both the query length and the result count are capped by the schema so a caller cannot request an unbounded scan.
+       *
+       * @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)
+    },
+    /** @experimental */
     plugins: {
       /**
        * Lists plugins installed in user/global state.
@@ -246,6 +276,15 @@ function createServerRpc(connection) {
        */
       disable: async (params) => connection.sendRequest("plugins.disable", params),
       /** @experimental */
+      builtin: {
+        /**
+         * Replaces this server's trusted built-in plugin directories while no sessions are active.
+         *
+         * @param params Trusted built-in plugin directories to use for this runtime process.
+         */
+        set: async (params) => connection.sendRequest("plugins.builtin.set", params)
+      },
+      /** @experimental */
       marketplaces: {
         /**
          * Lists all registered marketplaces (defaults + user-added).
@@ -296,7 +335,13 @@ function createServerRpc(connection) {
          *
          * @param params Skill names to mark as disabled in global configuration, replacing any previous list.
          */
-        setDisabledSkills: async (params) => connection.sendRequest("skills.config.setDisabledSkills", params)
+        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.
@@ -393,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: {
@@ -472,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.
        *
@@ -639,7 +696,7 @@ function createInternalServerRpc(connection) {
     /**
      * Performs the SDK server connection handshake and validates the optional connection token. Marked internal because this is JSON-RPC transport plumbing invoked automatically by an SDK client's own `connect()` wrapper, not a user-facing method. Stays internal as long as the SDK client owns the handshake; would only become public if the SDK ever exposed the raw schema surface to consumers without a connection wrapper.
      *
-     * @param params Parameters for the `server.connect` handshake: an optional connection token and optional connection-level opt-ins (e.g. GitHub telemetry forwarding).
+     * @param params Connection-level opt-ins for the `server.connect` handshake. Transport authentication is consumed by the native protocol boundary before dispatch.
      *
      * @returns Handshake result reporting the server's protocol version and package version on success.
      *
@@ -739,6 +796,15 @@ function createSessionRpc(connection, sessionId) {
      * @experimental
      */
     sendMessages: async (params) => connection.sendRequest("session.sendMessages", { sessionId, ...params }),
+    /** @experimental */
+    sandbox: {
+      /**
+       * Returns whether managed policy requires sandbox enforcement and whether an enforcement failure has permanently blocked the session.
+       *
+       * @returns Managed sandbox enforcement state for a session.
+       */
+      getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId })
+    },
     /**
      * Aborts the current agent turn.
      *
@@ -940,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 }),
       /**
@@ -953,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.
        *
@@ -982,6 +1056,8 @@ function createSessionRpc(connection, sessionId) {
        * Sets the current agent interaction mode.
        *
        * @param params Agent interaction mode to apply to the session.
+       *
+       * @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 })
     },
@@ -1157,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).
@@ -1250,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.
        *
@@ -1384,6 +1485,12 @@ function createSessionRpc(connection, sessionId) {
        * Reloads MCP server connections for the session.
        */
       reload: async () => connection.sendRequest("session.mcp.reload", { sessionId }),
+      /**
+       * Releases any turns waiting on an in-flight MCP load without cancelling the load, letting the agent proceed while MCP servers finish connecting in the background. No-op when no MCP load is in flight or waiting turns were already released.
+       *
+       * @returns Result of moving in-flight MCP loading to the background.
+       */
+      moveLoadingToBackground: async () => connection.sendRequest("session.mcp.moveLoadingToBackground", { sessionId }),
       /**
        * Runs an MCP sampling inference on behalf of an MCP server.
        *
@@ -1464,6 +1571,14 @@ function createSessionRpc(connection, sessionId) {
          * @returns OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
          */
         login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params }),
+        /**
+         * 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.
+         *
+         * @param params Remote MCP server name for a passive OAuth status probe.
+         *
+         * @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 }),
         /**
          * Responds to a pending MCP OAuth authorization request by its request id.
          *
@@ -1646,6 +1761,30 @@ function createSessionRpc(connection, sessionId) {
     },
     /** @experimental */
     tools: {
+      /**
+       * Executes one tool from the session's currently offered tool set through the native invocation pipeline.
+       *
+       * @param params A tool name and arguments to execute through the session's native invocation pipeline.
+       *
+       * @returns Canonical result returned by a session tool.
+       */
+      execute: async (params) => connection.sendRequest("session.tools.execute", { sessionId, ...params }),
+      /**
+       * Returns the Rust-owned built-in tool descriptors used to construct the session's offered tool set.
+       *
+       * @param params Options controlling how Rust-owned built-in tool descriptors are materialized.
+       *
+       * @returns Rust-owned built-in tool descriptors for the session.
+       */
+      getBuiltinDescriptors: async (params) => connection.sendRequest("session.tools.getBuiltinDescriptors", { sessionId, ...params }),
+      /**
+       * Projects a completed task_complete tool call into its label-safe session event payload.
+       *
+       * @param params Task-completion tool arguments and final result used to build a label-safe session event payload.
+       *
+       * @returns Task completion notification with summary from the agent
+       */
+      taskCompleteEventData: async (params) => connection.sendRequest("session.tools.taskCompleteEventData", { sessionId, ...params }),
       /**
        * Provides the result for a pending external tool call.
        *
@@ -1666,6 +1805,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Current lightweight tool metadata snapshot for the session.
        */
       getCurrentMetadata: async () => connection.sendRequest("session.tools.getCurrentMetadata", { sessionId }),
+      /**
+       * Atomically replaces the complete externally implemented tool list supplied by the calling connection. Built-in, MCP/plugin, extension-discovered, subagent, and tools supplied by other connections remain unchanged.
+       *
+       * @param params Complete externally implemented tool list for the calling connection. An empty list removes every tool previously supplied by that connection.
+       *
+       * @returns Empty result after replacing the calling connection's externally implemented tools.
+       */
+      set: async (params) => connection.sendRequest("session.tools.set", { sessionId, ...params }),
       /**
        * Updates the current session's live subagent settings after user settings change. The persisted user settings remain the source of truth for future sessions.
        *
@@ -1748,7 +1895,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Transient question to answer without adding it to conversation history.
        *
-       * @returns Transient answer generated from current conversation context.
+       * @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 }),
       /**
@@ -1855,19 +2002,19 @@ function createSessionRpc(connection, sessionId) {
        */
       setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { sessionId, ...params }),
       /**
-       * Sets the allow-all permission mode for the session. Used by attach-mode clients (e.g. LocalRpcSession's `/allow-all` forwarder) to flip the target session's permission state. The `on` mode swaps in unrestricted path and URL managers and emits `session.permissions_changed` on transition; the `auto` mode keeps normal prompt paths active while attaching LLM safety recommendations. The result returns the authoritative post-mutation state so callers can update their local mirrors without racing the `session.permissions_changed` notification on the same wire.
+       * 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.
        *
-       * @param params Allow-all mode to apply for the session.
+       * @param params Permission mode to apply for the session.
        *
-       * @returns Indicates whether the operation succeeded and reports the post-mutation state.
+       * @returns Indicates whether the requested permission mode was applied and reports the authoritative post-mutation mode.
        */
-      setAllowAll: async (params) => connection.sendRequest("session.permissions.setAllowAll", { sessionId, ...params }),
+      setMode: async (params) => connection.sendRequest("session.permissions.setMode", { sessionId, ...params }),
       /**
-       * Returns the current allow-all permission mode for the session.
+       * Returns the current permission mode for the session.
        *
-       * @returns Current allow-all permission mode.
+       * @returns Current permission mode.
        */
-      getAllowAll: async () => connection.sendRequest("session.permissions.getAllowAll", { sessionId }),
+      getMode: async () => connection.sendRequest("session.permissions.getMode", { sessionId }),
       /**
        * Adds or removes session-scoped or location-scoped permission rules.
        *
@@ -1909,7 +2056,7 @@ function createSessionRpc(connection, sessionId) {
          */
         list: async () => connection.sendRequest("session.permissions.paths.list", { sessionId }),
         /**
-         * Adds a directory to the session's allow-list.
+         * Adds a directory to the session's allow-list and activates conventional skill and agent definitions under it.
          *
          * @param params Directory path to add to the session's allowed directories.
          *
@@ -2385,6 +2532,109 @@ function createInternalSessionRpc(connection, sessionId) {
      */
     sendSystemNotification: async (params) => connection.sendRequest("session.sendSystemNotification", { sessionId, ...params }),
     /** @experimental */
+    gitHubAuth: {
+      /**
+       * Gets the current authentication information for internal session hosts.
+       *
+       * @returns Current authentication information, or null when no authentication is active.
+       */
+      getCurrentAuthInfo: async () => connection.sendRequest("session.gitHubAuth.getCurrentAuthInfo", { sessionId }),
+      /**
+       * Gets all authentication accounts available to the internal session host.
+       *
+       * @returns Authentication accounts available to the internal session host.
+       */
+      getAllAuthAvailable: async () => connection.sendRequest("session.gitHubAuth.getAllAuthAvailable", { sessionId }),
+      /**
+       * Refreshes Copilot account metadata for the current authentication.
+       *
+       * @returns Current authentication information, or null when no authentication is active.
+       */
+      refreshCopilotUser: async () => connection.sendRequest("session.gitHubAuth.refreshCopilotUser", { sessionId }),
+      /**
+       * Logs in a GitHub user through the internal session host.
+       *
+       * @param params Internal GitHub login parameters.
+       *
+       * @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 }),
+      /**
+       * 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 }),
+      /**
+       * Logs out the session's current GitHub authentication.
+       *
+       * @returns Whether the current authentication was logged out.
+       */
+      logout: async () => connection.sendRequest("session.gitHubAuth.logout", { sessionId }),
+      /**
+       * Logs out a specific GitHub authentication.
+       *
+       * @param params Parameters identifying a GitHub authentication to log out.
+       *
+       * @returns Whether the requested authentication was logged out.
+       */
+      logoutUser: async (params) => connection.sendRequest("session.gitHubAuth.logoutUser", { sessionId, ...params }),
+      /**
+       * Gets validation errors from the most recent authentication attempt.
+       *
+       * @returns Validation errors from the most recent authentication attempt.
+       */
+      lastAuthErrors: async () => connection.sendRequest("session.gitHubAuth.lastAuthErrors", { sessionId })
+    },
+    /** @experimental */
+    canvas: {
+      /** @experimental */
+      provider: {
+        /**
+         * Registers an internal canvas provider connection and its contributions.
+         *
+         * @param params Internal canvas provider registration parameters.
+         */
+        register: async (params) => connection.sendRequest("session.canvas.provider.register", { sessionId, ...params }),
+        /**
+         * Unregisters an internal canvas provider connection.
+         *
+         * @param params Internal canvas provider unregistration parameters.
+         */
+        unregister: async (params) => connection.sendRequest("session.canvas.provider.unregister", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
+    factory: {
+      /**
+       * Internal tool-originated factory invocation.
+       *
+       * @param params Internal parameters for invoking a registered factory from a tool.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      runFromTool: async (params) => connection.sendRequest("session.factory.runFromTool", { sessionId, ...params }),
+      /**
+       * Internal tool-originated factory resume.
+       *
+       * @param params Internal parameters for resuming a factory run from a tool.
+       *
+       * @returns Resolved persisted factory identity and resumed run envelope.
+       */
+      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params })
+    },
+    /** @experimental */
+    model: {
+      /**
+       * Resolves and applies organization-managed and repository model overlays.
+       *
+       * @param params Managed, repository, and CLI model overrides to overlay onto the session at startup.
+       *
+       * @returns The model identifier active on the session after the switch.
+       */
+      applyStartupOverlay: async (params) => connection.sendRequest("session.model.applyStartupOverlay", { sessionId, ...params })
+    },
+    /** @experimental */
     mcp: {
       /**
        * Reloads MCP server connections for the session with an explicit host-provided configuration.
@@ -2397,7 +2647,7 @@ function createInternalSessionRpc(connection, sessionId) {
       /**
        * Configures the built-in GitHub MCP server for the session's current auth context.
        *
-       * @param params Opaque auth info used to configure GitHub MCP.
+       * @param params Credential-free authentication identity used to configure GitHub MCP.
        *
        * @returns Result of configuring GitHub MCP.
        */
@@ -2416,6 +2666,17 @@ function createInternalSessionRpc(connection, sessionId) {
       unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params })
     },
     /** @experimental */
+    commands: {
+      /**
+       * Finalizes persistence associated with a client-applied slash-command effect.
+       *
+       * @param params The pending slash-command invocation effect to finalize, plus whether the host applied or cancelled it.
+       *
+       * @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 })
+    },
+    /** @experimental */
     settings: {
       /**
        * Returns a redacted snapshot of session runtime settings, with secrets and raw feature flags excluded. Internal: the runtime settings shape is a runtime-internal surface and is deliberately kept out of the public SDK, because consumers should not depend on the runtime's internal settings layout. It remains callable in-process and is expected to be reworked as the runtime internals are consolidated.
@@ -2558,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}`);
@@ -2660,6 +2926,11 @@ function registerClientGlobalApiHandlers(connection, handlers) {
     if (!handler) return;
     await handler.event(params);
   });
+  connection.onRequest("gitHubToken.getToken", async (params) => {
+    const handler = handlers.gitHubToken;
+    if (!handler) throw new Error("No gitHubToken client-global handler registered");
+    return handler.getToken(params);
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -27,6 +27,7 @@ __export(index_exports, {
   CopilotWebSocketCloseStatus: () => import_types2.CopilotWebSocketCloseStatus,
   CopilotWebSocketForwarder: () => import_types2.CopilotWebSocketForwarder,
   CopilotWebSocketHandler: () => import_types2.CopilotWebSocketHandler,
+  DisableBypassPermissionsModes: () => import_types.DisableBypassPermissionsModes,
   FactoryResumeError: () => import_factory.FactoryResumeError,
   RuntimeConnection: () => import_types.RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS: () => import_types2.SYSTEM_MESSAGE_SECTIONS,
@@ -60,6 +61,7 @@ var import_types2 = require("./types.js");
   CopilotWebSocketCloseStatus,
   CopilotWebSocketForwarder,
   CopilotWebSocketHandler,
+  DisableBypassPermissionsModes,
   FactoryResumeError,
   RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS,