@github/copilot-sdk 1.0.6-preview.0 → 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.
      *
@@ -621,14 +621,6 @@ function createInternalServerRpc(connection) {
        * @returns Dynamic-context board entry count, when available.
        */
       getBoardEntryCount: async (params) => connection.sendRequest("sessions.getBoardEntryCount", params),
-      /**
-       * Cursor-based long-poll for sessions spawned by the runtime (e.g. in response to a Mission Control `start_session` command). The cursor is an opaque token; pass it back to receive only spawn events that occurred AFTER the cursor was issued. Omit the cursor on the first call to receive any events buffered since the runtime started. Internal: this is a CLI background-daemon plumbing primitive. SDK consumers that need to react to runtime-spawned sessions should subscribe to a higher-level event stream rather than driving a long-poll loop.
-       *
-       * @param params Cursor and optional long-poll wait for polling runtime-spawned sessions.
-       *
-       * @returns Batch of spawn events plus a cursor for follow-up polls.
-       */
-      pollSpawnedSessions: async (params) => connection.sendRequest("sessions.pollSpawnedSessions", params),
       /**
        * Registers extension-provided tools on the given session, gated by an optional `enabled` callback. Returns an opaque unsubscribe function the caller must invoke to deregister the tools when the extension is torn down. Marked internal because `loader`, `enabled`, and the returned `unsubscribe` are in-process handles that cannot cross the JSON-RPC boundary. Disappears once extension discovery / launch / tool registration are owned by the runtime: SDK consumers will pass pure config (search paths, disabled ids) via `SessionOptions` and the runtime will resolve, launch, register, and tear down extensions itself.
        *
@@ -700,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.
@@ -1538,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 }),
       /**
@@ -1718,6 +1721,20 @@ function createSessionRpc(connection, sessionId) {
        * @returns Token breakdown for the session's current context window, or null if uninitialized.
        */
       contextInfo: async (params) => connection.sendRequest("session.metadata.contextInfo", { sessionId, ...params }),
+      /**
+       * Returns the experimental per-source attribution breakdown of the session's current context window as a flat list of entries (skills, subagents, MCP servers, built-in tools, plugin rollups, system/tool-definition costs, with nesting via parentId), plus the successful compaction count. The heaviest individual messages are available separately via `metadata.getContextHeaviestMessages`. Returns null until the session has initialized its system prompt and tool metadata.
+       *
+       * @returns Per-source attribution breakdown for the session's current context window, or null if uninitialized.
+       */
+      getContextAttribution: async () => connection.sendRequest("session.metadata.getContextAttribution", { sessionId }),
+      /**
+       * Returns the largest individual messages currently in the session's context window, most-expensive first. Companion to `metadata.getContextAttribution`. Returns an empty list until the session has initialized.
+       *
+       * @param params Parameters for the heaviest-messages query.
+       *
+       * @returns The heaviest individual messages in the session's context window, most-expensive first.
+       */
+      getContextHeaviestMessages: async (params) => connection.sendRequest("session.metadata.getContextHeaviestMessages", { sessionId, ...params }),
       /**
        * Records a working-directory/git context change and emits a `session.context_changed` event.
        *
@@ -1978,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")) {