@github/copilot-sdk 1.0.6-preview.1 → 1.0.7-preview.0

package/dist/cjs/client.js

@@ -1055,7 +1055,8 @@ class CopilotClient {
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
         cloud: config.cloud,
-        expAssignments: config.expAssignments
+        expAssignments: config.expAssignments,
+        enableManagedSettings: config.enableManagedSettings
       });
       const {
         sessionId: returnedSessionId,
@@ -1245,7 +1246,8 @@ class CopilotClient {
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
-        expAssignments: config.expAssignments
+        expAssignments: config.expAssignments,
+        enableManagedSettings: config.enableManagedSettings
       });
       const { workspacePath, capabilities, openCanvases } = response;
       session["_workspacePath"] = workspacePath;
@@ -1371,9 +1373,11 @@ class CopilotClient {
     const raceAgainstExit = (p) => this.processExitPromise ? Promise.race([p, this.processExitPromise]) : p;
     let serverVersion;
     try {
-      const result = await raceAgainstExit(
-        this.internalRpc.connect({ token: this.effectiveConnectionToken })
-      );
+      const connectParams = { token: this.effectiveConnectionToken };
+      if (this.onGitHubTelemetry != null) {
+        connectParams.enableGitHubTelemetryForwarding = true;
+      }
+      const result = await raceAgainstExit(this.internalRpc.connect(connectParams));
       serverVersion = result.protocolVersion;
     } catch (err) {
       if (err instanceof import_node.ResponseError && (err.code === import_node.ErrorCodes.MethodNotFound || err.message === "Unhandled method connect")) {

package/dist/cjs/generated/rpc.js

@@ -321,6 +321,15 @@ function createServerRpc(connection) {
       getDiscoveryPaths: async (params) => connection.sendRequest("instructions.getDiscoveryPaths", params)
     },
     /** @experimental */
+    commands: {
+      /**
+       * Lists the well-known built-in slash commands that work as the first message in a new session (e.g. /plan, /env), without requiring an active session. Commands that depend on session state, authentication, or a synced session are omitted.
+       *
+       * @returns Slash commands available in the session, after applying any include/exclude filters.
+       */
+      list: async () => connection.sendRequest("commands.list", {})
+    },
+    /** @experimental */
     user: {
       /** @experimental */
       settings: {
@@ -588,7 +597,7 @@ function createInternalServerRpc(connection) {
     /**
      * Performs the SDK server connection handshake and validates the optional connection token. Marked internal because this is JSON-RPC transport plumbing invoked automatically by an SDK client's own `connect()` wrapper, not a user-facing method. Stays internal as long as the SDK client owns the handshake; would only become public if the SDK ever exposed the raw schema surface to consumers without a connection wrapper.
      *
-     * @param params Optional connection token presented by the SDK client during the handshake.
+     * @param params Parameters for the `server.connect` handshake: an optional connection token and optional connection-level opt-ins (e.g. GitHub telemetry forwarding).
      *
      * @returns Handshake result reporting the server's protocol version and package version on success.
      *
@@ -656,6 +665,16 @@ function createSessionRpc(connection, sessionId) {
      * @experimental
      */
     send: async (params) => connection.sendRequest("session.send", { sessionId, ...params }),
+    /**
+     * Sends zero or more user messages to the session in a single turn and returns their message IDs. All provided messages are appended to the conversation in order, then exactly one agent turn runs over the resulting history. When the list is empty, one turn runs over the existing history with no new user message. Remote-backed (Mission Control) sessions do not support this method and will return an error.
+     *
+     * @param params Parameters for sending zero or more user messages to the session in a single turn. Remote-backed (Mission Control) sessions do not support this method and will return an error.
+     *
+     * @returns Result of sending zero or more user messages
+     *
+     * @experimental
+     */
+    sendMessages: async (params) => connection.sendRequest("session.sendMessages", { sessionId, ...params }),
     /**
      * Aborts the current agent turn.
      *
@@ -692,6 +711,17 @@ function createSessionRpc(connection, sessionId) {
       setCredentials: async (params) => connection.sendRequest("session.gitHubAuth.setCredentials", { sessionId, ...params })
     },
     /** @experimental */
+    debug: {
+      /**
+       * Collects a redacted session debug log bundle into a local archive or staging directory. The runtime includes session-owned logs by default and accepts caller-provided diagnostic entries so host applications can add their own files without changing this API shape.
+       *
+       * @param params Options for collecting a redacted session debug bundle.
+       *
+       * @returns Result of collecting a redacted debug bundle.
+       */
+      collectLogs: async (params) => connection.sendRequest("session.debug.collectLogs", { sessionId, ...params })
+    },
+    /** @experimental */
     canvas: {
       /**
        * Lists canvases declared for the session.
@@ -1142,6 +1172,18 @@ function createSessionRpc(connection, sessionId) {
        * @returns Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).
        */
       removeGitHub: async () => connection.sendRequest("session.mcp.removeGitHub", { sessionId }),
+      /**
+       * Starts an individual MCP server on the live session from a caller-supplied config. Session-scoped and ephemeral: the server is added to this session's running set only and is reaped when the session ends. Does NOT modify persistent user configuration (`mcp.config.*`), so it does not affect future sessions. The server surfaces through `session.mcp.list` and the `session.mcp_servers_loaded` / `session.mcp_server_status_changed` events like any other server.
+       *
+       * @param params Server name and configuration for an individual MCP server start.
+       */
+      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
+      /**
+       * Restarts an individual MCP server on the live session (stops then starts). Omit `config` for a config-free restart-by-name of an already-configured server; supply `config` to restart with a replacement configuration. Session-scoped and ephemeral: does NOT modify persistent user configuration (`mcp.config.*`).
+       *
+       * @param params Server name and optional replacement configuration for an individual MCP server restart. Omit `config` for a config-free restart-by-name of an already-configured server.
+       */
+      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { sessionId, ...params }),
       /**
        * Stops an individual MCP server on the session's host.
        *
@@ -1530,17 +1572,17 @@ function createSessionRpc(connection, sessionId) {
        */
       setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { sessionId, ...params }),
       /**
-       * Enables or disables full allow-all permissions (tools, paths, and URLs) for the session. Used by attach-mode clients (e.g. LocalRpcSession's `/allow-all` forwarder) to flip the target session's permission state. Unlike `setApproveAll`, this swaps in the unrestricted path and URL managers and emits `session.permissions_changed` on transition. The result returns the authoritative post-mutation state so callers can update their local mirrors without racing the `session.permissions_changed` notification on the same wire.
+       * Sets the allow-all permission mode for the session. Used by attach-mode clients (e.g. LocalRpcSession's `/allow-all` forwarder) to flip the target session's permission state. The `on` mode swaps in unrestricted path and URL managers and emits `session.permissions_changed` on transition; the `auto` mode keeps normal prompt paths active while attaching LLM safety recommendations. The result returns the authoritative post-mutation state so callers can update their local mirrors without racing the `session.permissions_changed` notification on the same wire.
        *
-       * @param params Whether to enable full allow-all permissions for the session.
+       * @param params Allow-all mode to apply for the session.
        *
        * @returns Indicates whether the operation succeeded and reports the post-mutation state.
        */
       setAllowAll: async (params) => connection.sendRequest("session.permissions.setAllowAll", { sessionId, ...params }),
       /**
-       * Returns whether full allow-all permissions are currently active for the session.
+       * Returns the current allow-all permission mode for the session.
        *
-       * @returns Current full allow-all permission state.
+       * @returns Current allow-all permission mode.
        */
       getAllowAll: async () => connection.sendRequest("session.permissions.getAllowAll", { sessionId }),
       /**
@@ -1962,40 +2004,34 @@ function createInternalSessionRpc(connection, sessionId) {
        */
       configureGitHub: async (params) => connection.sendRequest("session.mcp.configureGitHub", { sessionId, ...params }),
       /**
-       * Starts an individual MCP server on the session's host.
+       * Registers a pre-connected external MCP client (e.g. IDE) on the session's host. The caller retains lifecycle ownership of the client and transport. Marked internal because the `client` and `transport` arguments are in-process MCP SDK instances that cannot be serialized across the JSON-RPC boundary; once the CLI moves on top of the SDK, external clients will be expressed as transport configs the runtime can construct itself.
        *
-       * @param params Server name and opaque configuration for an individual MCP server start.
+       * @param params Registration parameters for an external MCP client.
        */
-      startServer: async (params) => connection.sendRequest("session.mcp.startServer", { sessionId, ...params }),
+      registerExternalClient: async (params) => connection.sendRequest("session.mcp.registerExternalClient", { sessionId, ...params }),
       /**
-       * Restarts an individual MCP server on the session's host (stops then starts).
+       * Unregisters a previously registered external MCP client by server name. Marked internal as the paired companion of `registerExternalClient`: only in-process callers that registered a client this way can meaningfully unregister it. Disappears alongside `registerExternalClient`: once external clients are described to the runtime as config rather than handed in as instances, lifecycle (including deregistration) is owned entirely by the runtime.
        *
-       * @param params Server name and opaque configuration for an individual MCP server restart.
+       * @param params Server name identifying the external client to remove.
        */
-      restartServer: async (params) => connection.sendRequest("session.mcp.restartServer", { sessionId, ...params }),
+      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params })
+    },
+    /** @experimental */
+    settings: {
       /**
-       * Registers a pre-connected external MCP client (e.g. IDE) on the session's host. The caller retains lifecycle ownership of the client and transport. Marked internal because the `client` and `transport` arguments are in-process MCP SDK instances that cannot be serialized across the JSON-RPC boundary; once the CLI moves on top of the SDK, external clients will be expressed as transport configs the runtime can construct itself.
+       * Returns a redacted snapshot of session runtime settings, with secrets and raw feature flags excluded. Internal: the runtime settings shape is a runtime-internal surface and is deliberately kept out of the public SDK, because consumers should not depend on the runtime's internal settings layout. It remains callable in-process and is expected to be reworked as the runtime internals are consolidated.
        *
-       * @param params Registration parameters for an external MCP client.
+       * @returns Redacted, serializable view of session runtime settings for SDK boundary consumers. Secrets and raw feature flags are intentionally excluded.
        */
-      registerExternalClient: async (params) => connection.sendRequest("session.mcp.registerExternalClient", { sessionId, ...params }),
+      snapshot: async () => connection.sendRequest("session.settings.snapshot", { sessionId }),
       /**
-       * Unregisters a previously registered external MCP client by server name. Marked internal as the paired companion of `registerExternalClient`: only in-process callers that registered a client this way can meaningfully unregister it. Disappears alongside `registerExternalClient`: once external clients are described to the runtime as config rather than handed in as instances, lifecycle (including deregistration) is owned entirely by the runtime.
+       * Evaluates a named Rust-owned settings predicate without exposing raw feature flags. Internal: the raw feature-flag names and composition are runtime-internal, so this predicate-evaluation helper is kept out of the public SDK surface and is callable in-process only.
        *
-       * @param params Server name identifying the external client to remove.
+       * @param params Named Rust-owned settings predicate to evaluate for this session.
+       *
+       * @returns Result of evaluating a Rust-owned settings predicate.
        */
-      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params }),
-      /** @experimental */
-      oauth: {
-        /**
-         * Responds to a pending MCP OAuth request with an in-process provider. This internal CLI-only API accepts a live OAuthClientProvider instance and cannot be used over the SDK JSON-RPC boundary. Use session.mcp.oauth.handlePendingRequest instead for the public SDK-safe response path.
-         *
-         * @param params MCP OAuth request id and optional provider response.
-         *
-         * @returns Empty result after recording the MCP OAuth response.
-         */
-        respond: async (params) => connection.sendRequest("session.mcp.oauth.respond", { sessionId, ...params })
-      }
+      evaluatePredicate: async (params) => connection.sendRequest("session.settings.evaluatePredicate", { sessionId, ...params })
     }
   };
 }

package/dist/client.js

@@ -1042,7 +1042,8 @@ class CopilotClient {
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
         cloud: config.cloud,
-        expAssignments: config.expAssignments
+        expAssignments: config.expAssignments,
+        enableManagedSettings: config.enableManagedSettings
       });
       const {
         sessionId: returnedSessionId,
@@ -1232,7 +1233,8 @@ class CopilotClient {
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
-        expAssignments: config.expAssignments
+        expAssignments: config.expAssignments,
+        enableManagedSettings: config.enableManagedSettings
       });
       const { workspacePath, capabilities, openCanvases } = response;
       session["_workspacePath"] = workspacePath;
@@ -1358,9 +1360,11 @@ class CopilotClient {
     const raceAgainstExit = (p) => this.processExitPromise ? Promise.race([p, this.processExitPromise]) : p;
     let serverVersion;
     try {
-      const result = await raceAgainstExit(
-        this.internalRpc.connect({ token: this.effectiveConnectionToken })
-      );
+      const connectParams = { token: this.effectiveConnectionToken };
+      if (this.onGitHubTelemetry != null) {
+        connectParams.enableGitHubTelemetryForwarding = true;
+      }
+      const result = await raceAgainstExit(this.internalRpc.connect(connectParams));
       serverVersion = result.protocolVersion;
     } catch (err) {
       if (err instanceof ResponseError && (err.code === ErrorCodes.MethodNotFound || err.message === "Unhandled method connect")) {