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

package/dist/cjs/client.js

@@ -1371,9 +1371,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

@@ -588,7 +588,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.
      *
@@ -692,6 +692,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.
@@ -1530,17 +1541,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 }),
       /**
@@ -1984,18 +1995,24 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @param params Server name identifying the external client to remove.
        */
-      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 })
-      }
+      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { 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.
+       *
+       * @returns Redacted, serializable view of session runtime settings for SDK boundary consumers. Secrets and raw feature flags are intentionally excluded.
+       */
+      snapshot: async () => connection.sendRequest("session.settings.snapshot", { sessionId }),
+      /**
+       * 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 Named Rust-owned settings predicate to evaluate for this session.
+       *
+       * @returns Result of evaluating a Rust-owned settings predicate.
+       */
+      evaluatePredicate: async (params) => connection.sendRequest("session.settings.evaluatePredicate", { sessionId, ...params })
     }
   };
 }

package/dist/client.js

@@ -1358,9 +1358,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")) {