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

package/dist/cjs/session.js

@@ -311,6 +311,7 @@ class CopilotSession {
   disconnected = false;
   pendingResponseWaits = /* @__PURE__ */ new Set();
   pendingStructuredWaits = /* @__PURE__ */ new Set();
+  completionRpcUnsupported = false;
   disconnecting = false;
   onDisconnected;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
@@ -512,9 +513,22 @@ class CopilotSession {
   }
   async send(optionsOrPrompt) {
     const options = typeof optionsOrPrompt === "string" ? { prompt: optionsOrPrompt } : optionsOrPrompt;
+    return this.sendMessage(options);
+  }
+  async sendMessage(options, cancelled) {
+    const message = await this.createSendParams(options);
+    if (cancelled?.()) {
+      throw new Error("Completion wait cancelled");
+    }
     const response = await this.connection.sendRequest("session.send", {
-      ...await (0, import_telemetry.getTraceContext)(this.traceContextProvider),
       sessionId: this.sessionId,
+      ...message
+    });
+    return response.messageId;
+  }
+  async createSendParams(options) {
+    return {
+      ...await (0, import_telemetry.getTraceContext)(this.traceContextProvider),
       prompt: options.prompt,
       source: options.source,
       displayPrompt: options.displayPrompt,
@@ -532,8 +546,7 @@ class CopilotSession {
           }
         }
       } : {}
-    });
-    return response.messageId;
+    };
   }
   async sendAndWait(optionsOrPrompt, schemaOrTimeout, timeout) {
     const options = typeof optionsOrPrompt === "string" ? { prompt: optionsOrPrompt } : optionsOrPrompt;
@@ -554,10 +567,39 @@ class CopilotSession {
         "Structured output cannot be requested on an immediate steering message."
       );
     }
+    const startedAt = Date.now();
+    const completion = await this.sendWithCompletion(
+      typedSchema ? { ...options, responseSchema: typedSchema } : options,
+      effectiveTimeout
+    );
+    if (completion !== void 0) {
+      const message = completion.response;
+      if (message !== void 0 && (message.type !== "assistant.message" || message.agentId)) {
+        throw new Error("The runtime returned a non-assistant response.");
+      }
+      if (typedSchema || options.responseSchema) {
+        if (completion.aborted) {
+          throw new Error(
+            "The requested run was aborted before a structured result was completed."
+          );
+        }
+        if (!message || message.data.toolRequests?.length || !message.data.content.trim()) {
+          throw new Error(
+            "The requested run completed without a structured assistant response."
+          );
+        }
+        return typedSchema ? typedSchema.parse(JSON.parse(message.data.content)) : message;
+      }
+      if (completion.aborted) {
+        throw new Error("The requested run was aborted before completion.");
+      }
+      return message;
+    }
+    const remainingTimeout = Math.max(0, effectiveTimeout - (Date.now() - startedAt));
     if (typedSchema || options.responseSchema) {
       const message = await this.sendAndWaitForStructuredMessage(
         typedSchema ? { ...options, responseSchema: typedSchema } : options,
-        effectiveTimeout
+        remainingTimeout
       );
       if (typedSchema) {
         if (!message) {
@@ -627,14 +669,8 @@ class CopilotSession {
     };
     this.pendingResponseWaits.add(fail);
     let timeoutId;
+    let waiting = true;
     try {
-      messageId = await this.send(options);
-      admitted = true;
-      for (const event of buffered) {
-        if (event instanceof Error) fail(event);
-        else observe(event);
-      }
-      buffered.length = 0;
       const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(
           () => reject(
@@ -642,15 +678,28 @@ class CopilotSession {
               `Timeout after ${effectiveTimeout}ms waiting for response completion`
             )
           ),
-          effectiveTimeout
+          remainingTimeout
         );
       });
-      const outcome = await Promise.race([outcomePromise, timeoutPromise]);
+      const outcome = await Promise.race([
+        this.sendMessage(options, () => !waiting).then((id) => {
+          messageId = id;
+          admitted = true;
+          for (const event of buffered) {
+            if (event instanceof Error) fail(event);
+            else observe(event);
+          }
+          buffered.length = 0;
+          return outcomePromise;
+        }),
+        timeoutPromise
+      ]);
       if (outcome.kind === "error") {
         throw outcome.error;
       }
       return outcome.message;
     } finally {
+      waiting = false;
       if (timeoutId !== void 0) {
         clearTimeout(timeoutId);
       }
@@ -659,6 +708,81 @@ class CopilotSession {
       this.pendingResponseWaits.delete(fail);
     }
   }
+  async sendWithCompletion(options, timeout) {
+    if (this.completionRpcUnsupported) return void 0;
+    if (this.disconnected) throw new Error("Session is disconnected");
+    const cancellation = new import_node.CancellationTokenSource();
+    const dispatched = /* @__PURE__ */ new Set();
+    let completionEventId;
+    let resolveDispatched;
+    const dispatchCompleted = new Promise((resolve) => {
+      resolveDispatched = resolve;
+    });
+    const unsubscribe = this.on((event) => {
+      if (event.agentId || event.type !== "session.idle" && event.type !== "session.autopilot_stopped" && event.type !== "session.error") {
+        return;
+      }
+      dispatched.add(event.id);
+      if (event.id === completionEventId) resolveDispatched();
+    });
+    const drain = async (id) => {
+      if (id && !dispatched.has(id)) {
+        completionEventId = id;
+        await dispatchCompleted;
+      }
+    };
+    let fail;
+    const stopped = new Promise((_, reject) => {
+      fail = reject;
+    });
+    this.pendingResponseWaits.add(fail);
+    const timer = setTimeout(
+      () => fail(new Error(`Timeout after ${timeout}ms waiting for session.idle`)),
+      timeout
+    );
+    const operation = async () => {
+      try {
+        const message = await this.createSendParams(options);
+        if (cancellation.token.isCancellationRequested) {
+          throw new Error("Completion wait cancelled");
+        }
+        const result = await this.connection.sendRequest(
+          "session.sendAndWait",
+          {
+            sessionId: this.sessionId,
+            ...message
+          },
+          cancellation.token
+        );
+        await drain(result.completionEventId);
+        return result;
+      } catch (error) {
+        if (error instanceof import_node.ResponseError && error.code === import_node.ErrorCodes.MethodNotFound) {
+          this.completionRpcUnsupported = true;
+          return void 0;
+        }
+        if (error instanceof import_node.ResponseError && typeof error.data === "object" && error.data !== null) {
+          if ("stack" in error.data && typeof error.data.stack === "string") {
+            error.stack = error.data.stack;
+          }
+          if ("completionEventId" in error.data && typeof error.data.completionEventId === "string") {
+            await drain(error.data.completionEventId);
+          }
+        }
+        throw error;
+      }
+    };
+    try {
+      return await Promise.race([operation(), stopped]);
+    } finally {
+      clearTimeout(timer);
+      unsubscribe();
+      this.pendingResponseWaits.delete(fail);
+      resolveDispatched();
+      cancellation.cancel();
+      cancellation.dispose();
+    }
+  }
   async sendAndWaitForStructuredMessage(options, timeout) {
     if (this.disconnected) {
       throw new Error("Session is disconnected");
@@ -708,12 +832,13 @@ class CopilotSession {
       }
     });
     this.pendingStructuredWaits.add(fail);
+    let waiting = true;
     const timer = setTimeout(
       () => fail(new Error(`Timeout after ${timeout}ms waiting for the structured response`)),
       timeout
     );
     try {
-      const sendOutcome = this.send(options).then(
+      const sendOutcome = this.sendMessage(options, () => !waiting).then(
         (id) => {
           if (!id) {
             throw new Error(
@@ -734,6 +859,7 @@ class CopilotSession {
       if (outcome.kind === "error") throw outcome.error;
       return outcome.message;
     } finally {
+      waiting = false;
       clearTimeout(timer);
       buffered.length = 0;
       unsubscribe();

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.102";
+export declare const COPILOT_CLI_VERSION = "1.0.103-0";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.102";
+const COPILOT_CLI_VERSION = "1.0.103-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.d.ts

@@ -20,6 +20,8 @@ export declare class CopilotClient {
     private sessions;
     private hostExitCallbacks;
     private hostSessionFactories;
+    private hostAuthenticators;
+    private hostAuthentications;
     private hostHandoffs;
     private stderrBuffer;
     /** Resolved connection mode chosen in the constructor. */

package/dist/client.js

@@ -18,7 +18,9 @@ import {
 } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession } from "./session.js";
-import { AhpHost } from "./host.js";
+import {
+  AhpHost
+} from "./host.js";
 import { ensureRuntimeBundle } from "./runtimeArtifacts.js";
 import { COPILOT_CLI_VERSION } from "./cliVersion.js";
 import { createSessionFsAdapter } from "./sessionFsProvider.js";
@@ -273,6 +275,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
@@ -477,6 +481,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,
@@ -485,7 +490,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
     };
@@ -1399,7 +1403,6 @@ class CopilotClient {
         memory: config.memory,
         gitHubToken: config.gitHubToken,
         gitHubTokenProviderRegistrationId,
-        remoteSession: config.remoteSession,
         cloud: config.cloud,
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
@@ -1675,7 +1678,6 @@ class CopilotClient {
         continuePendingWork: config.continuePendingWork,
         gitHubToken: config.gitHubToken,
         gitHubTokenProviderRegistrationId,
-        remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
@@ -1745,6 +1747,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");
     }
@@ -1753,8 +1767,12 @@ class CopilotClient {
     }
     const rpc = this.rpc;
     const hostId = randomUUID();
+    if (authentication.mode === "custom") {
+      this.hostAuthenticators.set(hostId, { ...authentication });
+    }
     const {
       computeId,
+      allowCreatingNewSessions,
       localServer,
       githubEnvironment,
       onExit,
@@ -1766,7 +1784,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) {
@@ -1775,11 +1797,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 AhpHost(
         info,
@@ -1788,7 +1812,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);
@@ -1814,7 +1844,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,
@@ -1824,6 +1855,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);
@@ -1852,10 +1890,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,
@@ -1882,12 +1929,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
       });
@@ -2034,6 +2083,7 @@ class CopilotClient {
     let serverVersion;
     try {
       const connectParams = {
+        entra: this.options.entra,
         token: this.effectiveConnectionToken,
         supportedTaskKinds: ["agent", "client", "shell"]
       };
@@ -2048,6 +2098,9 @@ class CopilotClient {
       serverVersion = result.protocolVersion;
     } catch (err) {
       if (err instanceof ResponseError && (err.code === 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;
@@ -2334,9 +2387,6 @@ class CopilotClient {
           this.options.sessionIdleTimeoutSeconds.toString()
         );
       }
-      if (this.options.enableRemoteSessions) {
-        args.push("--remote");
-      }
       const envWithoutNodeDebug = this.buildRuntimeEnv();
       if (!this.resolvedCliPath) {
         throw new Error(
@@ -2522,9 +2572,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}`);
     }
@@ -2700,6 +2747,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) => {