@github/copilot-sdk 1.0.25 → 1.0.26-preview.0

package/README.md

@@ -43,8 +43,8 @@ npm install @github/copilot-sdk
 
 ## Runtime-supervised AHP host (experimental)
 
-`startAhpHost()` exposes copilotd's complete Agent Host Protocol server through the
-same runtime used by the SDK:
+`startAhpHost()` requires `authentication`: `github`, or direct-only `none` / `custom`
+(`requireIdentity` and a validator returning `{identity,expiresAt}` or `null`):
 
 ```typescript
 import { CopilotClient } from "@github/copilot-sdk";
@@ -52,7 +52,7 @@ import { CopilotClient } from "@github/copilot-sdk";
 await using client = new CopilotClient();
 await client.start();
 const host = await client.startAhpHost({
-    localServer: {},
+    localServer: {}, authentication: { mode: "github" },
     onExit: (exit) => {
         if (exit.error) console.error(exit.error);
     },
@@ -121,7 +121,7 @@ import { approveAll, CopilotClient, defineTool } from "@github/copilot-sdk";
 
 await using client = new CopilotClient();
 await using host = await client.startAhpHost({
-    localServer: {},
+    localServer: {}, authentication: { mode: "github" },
     createSession: ({ config, signal }) => {
         signal.throwIfAborted();
         return client.createSession({
@@ -306,7 +306,6 @@ Binary reads and writes are limited to 50,330,880 raw bytes (approximately 48 Mi
 larger results return a filesystem error before encoding or decoding.
 
 - `sessionIdleTimeoutSeconds?: number` - Server-wide idle timeout for sessions in seconds. Ignored when connecting via `RuntimeConnection.forUri`.
-- `enableRemoteSessions?: boolean` - Enable Mission Control remote session support. Ignored when connecting via `RuntimeConnection.forUri`.
 
 #### Installation confirmation (experimental)
 
@@ -543,11 +542,11 @@ Source is independent of delivery mode. Leaving it unset preserves the existing
 
 ##### `sendAndWait(options: MessageOptions, timeout?: number): Promise<AssistantMessageEvent | undefined>`
 
-Send a message and wait for response completion: non-Autopilot `session.idle`,
-or the request's root `session.autopilot_stopped` event in Autopilot.
-The latter does not wait for attached shells to finish and does not stop them.
-`session.idle` still means whole-session quiescence; neither `assistant.idle`
-nor `session.task_complete` alone completes the wait.
+Send a message and wait for its request-owned response completion.
+Remote sessions retain the legacy non-Autopilot `session.idle` or correlated
+`session.autopilot_stopped` wait. Autopilot completion does not wait for or stop
+attached shells. Neither `assistant.idle` nor `session.task_complete` alone
+completes the wait.
 Sub-agent events are still delivered to listeners, but do not complete the wait or supply its reply.
 
 **Options:**
@@ -617,19 +616,12 @@ admission. Schemas larger than 32 MiB when JSON-encoded are also rejected before
 admission, using the runtime's existing request-size ceiling. This does not
 guarantee the schema plus conversation and tools fits the provider's budget.
 
-Structured waits select the last root-agent message whose `originatingMessageId`
-matches the ID returned by their send, then return at a non-autopilot
-`session.idle` or a root `session.autopilot_stopped` whose `requestId` matches
-that original send ID. Automatic continuation messages do not change ownership.
-An absent or different `requestId` cannot complete a correlated wait.
-Other queued work can delay idle, but cannot replace the selected result.
-Unformatted waits also isolate their replies and accept idle only after their
-own request starts. Both forms ignore child-agent events and `session.error`
-events whose `originatingMessageId` belongs to another request. A matching error
-fails its own wait even before a user message is emitted. Errors without an ID
-retain legacy handling: unformatted waits treat them as session-wide, while
-structured waits require their request to have started. Older hosts that omit
-error IDs cannot provide concurrent request-error isolation.
+Structured and unformatted waits return their request's root-agent response when
+its execution completes. Remote sessions retain event-based completion, selecting
+the response and Autopilot terminal by originating request ID. Automatic
+continuation messages do not change ownership. Child-agent events cannot supply
+the result. Legacy errors without an ID cannot provide concurrent request-error
+isolation.
 `turnId` identifies an individual model/tool iteration, not the whole
 run; telemetry interaction IDs are not unique run identifiers.
 

package/dist/cjs/cliVersion.js

@@ -22,7 +22,7 @@ __export(cliVersion_exports, {
   COPILOT_CLI_VERSION: () => COPILOT_CLI_VERSION
 });
 module.exports = __toCommonJS(cliVersion_exports);
-const COPILOT_CLI_VERSION = "1.0.102";
+const COPILOT_CLI_VERSION = "1.0.103-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/client.js

@@ -293,6 +293,8 @@ class CopilotClient {
   sessions = /* @__PURE__ */ new Map();
   hostExitCallbacks = /* @__PURE__ */ new Map();
   hostSessionFactories = /* @__PURE__ */ new Map();
+  hostAuthenticators = /* @__PURE__ */ new Map();
+  hostAuthentications = /* @__PURE__ */ new Map();
   hostHandoffs = /* @__PURE__ */ new Map();
   stderrBuffer = "";
   // Captures CLI stderr for error messages
@@ -497,6 +499,7 @@ class CopilotClient {
     const connArgs = conn.kind === "stdio" || conn.kind === "tcp" ? conn.args ?? [] : [];
     this.connectionExtraArgs = [...connArgs];
     this.options = {
+      entra: options.entra ? { ...options.entra } : void 0,
       workingDirectory: options.workingDirectory ?? process.cwd(),
       logLevel: options.logLevel,
       gitHubToken: options.gitHubToken,
@@ -505,7 +508,6 @@ class CopilotClient {
       telemetry: options.telemetry,
       baseDirectory: options.baseDirectory,
       sessionIdleTimeoutSeconds: options.sessionIdleTimeoutSeconds ?? 0,
-      enableRemoteSessions: options.enableRemoteSessions ?? false,
       mode: options.mode ?? "copilot-cli",
       clientInfo: options.clientInfo
     };
@@ -1419,7 +1421,6 @@ class CopilotClient {
         memory: config.memory,
         gitHubToken: config.gitHubToken,
         gitHubTokenProviderRegistrationId,
-        remoteSession: config.remoteSession,
         cloud: config.cloud,
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
@@ -1695,7 +1696,6 @@ class CopilotClient {
         continuePendingWork: config.continuePendingWork,
         gitHubToken: config.gitHubToken,
         gitHubTokenProviderRegistrationId,
-        remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
@@ -1765,6 +1765,18 @@ class CopilotClient {
    * @experimental
    */
   async startAhpHost(options) {
+    const authentication = options?.authentication;
+    if (!authentication || !["github", "none", "custom"].includes(authentication.mode)) {
+      throw new Error("An explicit authentication mode is required");
+    }
+    if (authentication.mode === "custom" && (typeof authentication.requireIdentity !== "string" || !authentication.requireIdentity.trim() || typeof authentication.authenticate !== "function")) {
+      throw new Error(
+        "Custom authentication requires a nonempty requireIdentity and authenticate callback"
+      );
+    }
+    if (authentication.mode !== "github" && options.githubEnvironment) {
+      throw new Error("githubEnvironment requires github authentication");
+    }
     if (!options?.localServer && !options?.githubEnvironment) {
       throw new Error("At least one of localServer or githubEnvironment is required");
     }
@@ -1773,8 +1785,12 @@ class CopilotClient {
     }
     const rpc = this.rpc;
     const hostId = (0, import_node_crypto.randomUUID)();
+    if (authentication.mode === "custom") {
+      this.hostAuthenticators.set(hostId, { ...authentication });
+    }
     const {
       computeId,
+      allowCreatingNewSessions,
       localServer,
       githubEnvironment,
       onExit,
@@ -1786,7 +1802,11 @@ class CopilotClient {
       this.hostSessionFactories.set(hostId, {
         createSession,
         resumeSession,
-        onSessionReleased
+        onSessionReleased,
+        policy: {
+          mode: authentication.mode,
+          requireIdentity: authentication.mode === "custom" ? authentication.requireIdentity : void 0
+        }
       });
     }
     if (onExit) {
@@ -1795,11 +1815,13 @@ class CopilotClient {
     try {
       const info = await rpc.host.start({
         hostId,
+        authentication: authentication.mode === "custom" ? { mode: "custom", requireIdentity: authentication.requireIdentity } : { mode: authentication.mode },
         computeId,
         localServer,
         githubEnvironment,
         sessionFactory: createSession ? true : void 0,
-        resumeFactory: resumeSession ? true : void 0
+        resumeFactory: resumeSession ? true : void 0,
+        allowCreatingNewSessions
       });
       return new import_host.AhpHost(
         info,
@@ -1808,7 +1830,13 @@ class CopilotClient {
         },
         (sessionId) => rpc.host.publishSession({ hostId, sessionId }),
         () => rpc.host.listSessions({ hostId }),
-        (sessionId) => rpc.host.unpublishSession({ hostId, sessionId })
+        (sessionId) => rpc.host.unpublishSession({ hostId, sessionId }),
+        async (allowed) => {
+          await rpc.host.setSessionCreationPolicy({
+            hostId,
+            allowCreatingNewSessions: allowed
+          });
+        }
       );
     } catch (error) {
       this.hostExitCallbacks.delete(hostId);
@@ -1834,7 +1862,8 @@ class CopilotClient {
   disconnectHosts() {
     for (const hostId of /* @__PURE__ */ new Set([
       ...this.hostExitCallbacks.keys(),
-      ...this.hostSessionFactories.keys()
+      ...this.hostSessionFactories.keys(),
+      ...this.hostAuthenticators.keys()
     ])) {
       this.handleHostExit({
         hostId,
@@ -1844,6 +1873,13 @@ class CopilotClient {
     }
   }
   releaseHostSessions(hostId) {
+    this.hostAuthenticators.delete(hostId);
+    for (const [requestId, entry] of this.hostAuthentications) {
+      if (entry.hostId === hostId) {
+        this.hostAuthentications.delete(requestId);
+        entry.controller.abort();
+      }
+    }
     this.hostSessionFactories.delete(hostId);
     for (const [handoffId, entry] of this.hostHandoffs) {
       if (entry.hostId === hostId) this.releaseHostSession(handoffId);
@@ -1872,10 +1908,19 @@ class CopilotClient {
     }
   }
   async createHostSession(params) {
+    const authentication = params.authentication;
+    if (!authentication) {
+      throw new Error("AHP session handoff authentication is required");
+    }
     const options = this.hostSessionFactories.get(params.hostId);
     if (!(params.resume ? options?.resumeSession : options?.createSession) || this.hostHandoffs.has(params.handoffId)) {
       throw new Error("AHP session factory is unavailable or handoff already exists");
     }
+    const policy = options.policy;
+    const identity = authentication.identity;
+    if (authentication.mode !== policy.mode || (authentication.mode === "none" ? identity !== void 0 : typeof identity !== "string" || !identity.trim()) || policy.mode === "custom" && identity !== policy.requireIdentity) {
+      throw new Error("AHP trusted authentication does not match host policy");
+    }
     const entry = {
       hostId: params.hostId,
       requestedSessionId: params.config.sessionId,
@@ -1902,12 +1947,14 @@ class CopilotClient {
         const { sessionId, ...resumeConfig } = config;
         if (!sessionId) throw new Error("AHP resume requires sessionId");
         return options.resumeSession({
+          authentication,
           sessionId,
           config: resumeConfig,
           signal: entry.controller.signal
         });
       }
       return options.createSession({
+        authentication,
         config,
         signal: entry.controller.signal
       });
@@ -2054,6 +2101,7 @@ class CopilotClient {
     let serverVersion;
     try {
       const connectParams = {
+        entra: this.options.entra,
         token: this.effectiveConnectionToken,
         supportedTaskKinds: ["agent", "client", "shell"]
       };
@@ -2068,6 +2116,9 @@ class CopilotClient {
       serverVersion = result.protocolVersion;
     } catch (err) {
       if (err instanceof import_node.ResponseError && (err.code === import_node.ErrorCodes.MethodNotFound || err.message === "Unhandled method connect")) {
+        if (this.options.entra) {
+          throw new Error("This runtime does not support Entra client configuration.");
+        }
         serverVersion = (await raceAgainstExit(this.ping())).protocolVersion;
       } else {
         throw err;
@@ -2354,9 +2405,6 @@ class CopilotClient {
           this.options.sessionIdleTimeoutSeconds.toString()
         );
       }
-      if (this.options.enableRemoteSessions) {
-        args.push("--remote");
-      }
       const envWithoutNodeDebug = this.buildRuntimeEnv();
       if (!this.resolvedCliPath) {
         throw new Error(
@@ -2542,9 +2590,6 @@ stderr: ${this.stderrBuffer.trim().slice(-8192) || "(empty)"}`
     if (this.options.sessionIdleTimeoutSeconds > 0) {
       args.push("--session-idle-timeout", this.options.sessionIdleTimeoutSeconds.toString());
     }
-    if (this.options.enableRemoteSessions) {
-      args.push("--remote");
-    }
     if (cliLoginSyncIntegrationId) {
       args.push(`--cli-login-sync-integration-id=${cliLoginSyncIntegrationId}`);
     }
@@ -2720,6 +2765,49 @@ stderr: ${stderrOutput}` : ""}`
       "host.materializeSession",
       (params) => this.createHostSession(params)
     );
+    this.connection.onRequest(
+      "host.validateAuthentication",
+      async (params) => {
+        const authenticator = this.hostAuthenticators.get(params.hostId);
+        if (!authenticator || this.hostAuthentications.has(params.requestId)) {
+          throw new Error("AHP authenticator is unavailable or request already exists");
+        }
+        const entry = { hostId: params.hostId, controller: new AbortController() };
+        this.hostAuthentications.set(params.requestId, entry);
+        const signal = entry.controller.signal;
+        const cancelled = new Promise((_resolve, reject) => {
+          signal.addEventListener(
+            "abort",
+            () => reject(new Error("AHP authentication ended")),
+            { once: true }
+          );
+        });
+        try {
+          const result = await Promise.race([
+            Promise.resolve().then(
+              () => authenticator.authenticate({ token: params.token, signal })
+            ),
+            cancelled
+          ]);
+          if (signal.aborted || this.hostAuthenticators.get(params.hostId) !== authenticator) {
+            throw new Error("AHP authentication ended");
+          }
+          return result;
+        } finally {
+          if (this.hostAuthentications.get(params.requestId) === entry) {
+            this.hostAuthentications.delete(params.requestId);
+          }
+          entry.controller.abort();
+        }
+      }
+    );
+    this.connection.onNotification(
+      "host.authenticationCancelled",
+      (params) => {
+        const entry = this.hostAuthentications.get(params.requestId);
+        if (entry?.hostId === params.hostId) entry.controller.abort();
+      }
+    );
     this.connection.onNotification(
       "host.sessionReleased",
       (params) => {

package/dist/cjs/generated/rpc.js

@@ -232,7 +232,15 @@ function createServerRpc(connection) {
        *
        * @returns Empty acknowledgement for a completed host lifecycle operation.
        */
-      dispose: async (params) => connection.sendRequest("host.dispose", params)
+      dispose: async (params) => connection.sendRequest("host.dispose", params),
+      /**
+       * Changes remote creation admission on a host owned by this SDK connection without disconnecting clients. Acknowledgement means subsequent admissions use the new policy; already-admitted creation may complete.
+       *
+       * @param params Changes remote session creation admission without disconnecting clients.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      setSessionCreationPolicy: async (params) => connection.sendRequest("host.setSessionCreationPolicy", params)
     },
     /**
      * Checks server responsiveness and returns protocol information.
@@ -1702,6 +1710,28 @@ function createInternalServerRpc(connection) {
        * @returns Normalized listener settings delivered only to the supervised hosting participant.
        */
       getConfiguration: async () => connection.sendRequest("host.getConfiguration", {}),
+      /**
+       * Resolves the host account credential without applying Mission Control transport policy, only for its supervised GitHub hosting participant.
+       *
+       * @returns Private credentials delivered only to a runtime-owned Mission Control hosting participant.
+       */
+      getAuthenticationCredentials: async () => connection.sendRequest("host.getAuthenticationCredentials", {}),
+      /**
+       * Validates a decrypted admission credential through the owning application, only for its supervised custom-authentication participant.
+       *
+       * @param params A decrypted credential presented by a supervised hosting participant.
+       *
+       * @returns Validated admission credential, or null when the application rejects it.
+       */
+      authenticate: async (params) => connection.sendRequest("host.authenticate", params),
+      /**
+       * Cancels a supervised participant's pending admission validation.
+       *
+       * @param params Cancels a pending validation on the supervised participant's connection.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      cancelAuthentication: async (params) => connection.sendRequest("host.cancelAuthentication", params),
       /**
        * Reports a supervised hosting participant's bound AHP endpoint after its SDK handshake.
        *
@@ -3560,7 +3590,13 @@ function createSessionRpc(connection, sessionId) {
        */
       set: async (params) => connection.sendRequest("session.tools.set", { ...params, sessionId }),
       /**
-       * Sets the current session's live subagent settings override, which takes precedence over persisted user settings until cleared. Persisted user settings remain the source of truth for future sessions.
+       * Returns the session's live subagent settings override, or the current persisted user settings when no override is active. Returns null in subagents when no settings block exists; defaults, model inheritance, and billing limits are not resolved. Persisted settings are loaded strictly, including before the first turn, and loading errors are reported. Reading does not change the session or persist settings. Read-modify-write with updateSubagentSettings is not atomic; writing back creates a live override that ignores later persisted changes until cleared.
+       *
+       * @returns Current configured subagent settings for the session, before resolving defaults or inheritance.
+       */
+      getSubagentSettings: async () => connection.sendRequest("session.tools.getSubagentSettings", { sessionId }),
+      /**
+       * Replaces the current session's complete live subagent settings override; nested fields are not merged. The override takes precedence over persisted user settings until cleared. Persisted user settings remain the source of truth for future sessions.
        *
        * @param params Subagent settings to apply to the current session
        *
@@ -4320,6 +4356,16 @@ function createSessionRpc(connection, sessionId) {
 }
 function createInternalSessionRpc(connection, sessionId) {
   return {
+    /**
+     * Submits one message through normal admission and waits for its request-owned completion. Returns the exact root assistant event, or an explicit aborted/no-response outcome. Cancelling or timing out the wait does not abort agent work. Unsupported execution hosts reject the method before admitting the message.
+     *
+     * @param params Parameters for sending a user message to the session
+     *
+     * @returns Internal request-correlated completion of one submitted message.
+     *
+     * @experimental
+     */
+    sendAndWait: async (params) => connection.sendRequest("session.sendAndWait", { ...params, sessionId }),
     /**
      * Queues or sends an internal system notification to the session according to its passive policy.
      *

package/dist/cjs/host.js

@@ -23,11 +23,12 @@ __export(host_exports, {
 module.exports = __toCommonJS(host_exports);
 class AhpHost {
   /** @internal */
-  constructor(info, disposeHost, publishHostSession, listHostSessions, unpublishHostSession) {
+  constructor(info, disposeHost, publishHostSession, listHostSessions, unpublishHostSession, updateCreationPolicy) {
     this.disposeHost = disposeHost;
     this.publishHostSession = publishHostSession;
     this.listHostSessions = listHostSessions;
     this.unpublishHostSession = unpublishHostSession;
+    this.updateCreationPolicy = updateCreationPolicy;
     this.hostId = info.hostId;
     this.url = info.url;
     this.environmentId = info.environmentId;
@@ -38,6 +39,7 @@ class AhpHost {
   publishHostSession;
   listHostSessions;
   unpublishHostSession;
+  updateCreationPolicy;
   hostId;
   /** Local WebSocket URL. Absent when only the GitHub environment is enabled. */
   url;
@@ -51,6 +53,10 @@ class AhpHost {
   dispose() {
     return this.disposeHost();
   }
+  /** Change subsequent remote admissions without disconnecting clients; admitted creation may finish. */
+  setAllowCreatingNewSessions(allowed) {
+    return this.updateCreationPolicy(allowed);
+  }
   /** Publish an attached application session into the durable compute-scoped host catalog. */
   publishSession(sessionId) {
     return this.publishHostSession(sessionId);