@github/copilot-language-server 1.561.0 → 1.563.0

package/dist/node_modules/@github/copilot-sdk/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.96";
+const COPILOT_CLI_VERSION = "1.0.103";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/node_modules/@github/copilot-sdk/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
     };
@@ -620,6 +622,16 @@ class CopilotClient {
     handlers.gitHubToken = {
       getToken: (params) => this.acquireGitHubToken(params)
     };
+    handlers.uiThread = {
+      run: async ({ actionId }) => {
+        const connection = this.connectionConfig;
+        const host = this.ffiHost;
+        if (connection.kind !== "inprocess" || !connection.runOnUiThread || !host) {
+          throw new Error("No in-process runOnUiThread handler is configured.");
+        }
+        await connection.runOnUiThread(() => host.runUiAction(actionId));
+      }
+    };
     this.clientGlobalHandlers = handlers;
   }
   async acquireGitHubToken(params) {
@@ -780,11 +792,19 @@ class CopilotClient {
       const sessionId = session.sessionId;
       let lastError = null;
       for (let attempt = 1; attempt <= 3; attempt++) {
+        if (this.connectionClosed) {
+          lastError = null;
+          break;
+        }
         try {
           await session.disconnect();
           lastError = null;
           break;
         } catch (error) {
+          if (this.connectionClosed) {
+            lastError = null;
+            break;
+          }
           lastError = error instanceof Error ? error : new Error(String(error));
           if (attempt < 3) {
             const delay = 100 * Math.pow(2, attempt - 1);
@@ -970,8 +990,10 @@ class CopilotClient {
    * - Clears all sessions immediately without destroying them
    * - Force closes the connection
    * - Sends SIGKILL to the CLI process (if spawned by this client)
+   * - Waits for the spawned CLI process to exit
    *
    * @returns A promise that resolves when the force stop is complete
+   * @throws If the spawned CLI process cannot be terminated
    *
    * @example
    * ```typescript
@@ -1018,13 +1040,6 @@ class CopilotClient {
       }
       this.socket = null;
     }
-    if (this.cliProcess && !this.isExternalServer) {
-      try {
-        this.cliProcess.kill("SIGKILL");
-      } catch {
-      }
-      this.cliProcess = null;
-    }
     if (this.ffiHost) {
       const host = this.ffiHost;
       this.ffiHost = null;
@@ -1041,6 +1056,20 @@ class CopilotClient {
     this.runtimePort = null;
     this.stderrBuffer = "";
     this.processExitPromise = null;
+    if (this.cliProcess && !this.isExternalServer) {
+      const child = this.cliProcess;
+      if (child.exitCode == null && child.signalCode == null) {
+        child.kill("SIGKILL");
+        if (!await waitForChildExit(child, RUNTIME_SHUTDOWN_TIMEOUT_MS)) {
+          throw new Error(
+            `Timed out waiting for CLI process to exit after SIGKILL: ${RUNTIME_SHUTDOWN_TIMEOUT_MS}ms`
+          );
+        }
+      }
+      if (this.cliProcess === child) {
+        this.cliProcess = null;
+      }
+    }
   }
   /**
    * Creates a new conversation session with the Copilot CLI.
@@ -1299,6 +1328,7 @@ class CopilotClient {
         model: config.model,
         allowedModels: config.allowedModels,
         sessionId: localSessionId,
+        name: config.name,
         clientName: config.clientName,
         reasoningEffort: config.reasoningEffort,
         reasoningSummary: config.reasoningSummary,
@@ -1312,7 +1342,8 @@ class CopilotClient {
           skipPermission: tool.skipPermission,
           defer: tool.defer,
           metadata: tool.metadata,
-          isTerminal: tool.isTerminal
+          isTerminal: tool.isTerminal,
+          namespace: tool.namespace
         })),
         toolSearch: config.toolSearch,
         imageGeneration: config.imageGeneration,
@@ -1339,6 +1370,7 @@ class CopilotClient {
         enableCitations: config.enableCitations,
         enableFileChangeTracking: config.enableFileChangeTracking,
         sessionLimits: config.sessionLimits,
+        autopilot: config.autopilot,
         modelCapabilities: config.modelCapabilities,
         largeOutput: toWireLargeOutput(config.largeOutput),
         requestPermission: !!config.onPermissionRequest,
@@ -1351,6 +1383,7 @@ class CopilotClient {
         requestAutoModeSwitch: !!config.onAutoModeSwitchRequest,
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
         workingDirectory: config.workingDirectory,
+        trustWorkingDirectory: config.trustWorkingDirectory,
         additionalDirectories: config.additionalDirectories,
         streaming: config.streaming,
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
@@ -1377,20 +1410,23 @@ class CopilotClient {
         enableSkills: config.enableSkills,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        agentDirectories: config.agentDirectories,
+        hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
         disabledMcpServers: config.disabledMcpServers,
+        sandboxConfig: config.sandboxConfig,
         infiniteSessions: config.infiniteSessions,
         memory: config.memory,
         gitHubToken: config.gitHubToken,
         gitHubTokenProviderRegistrationId,
-        remoteSession: config.remoteSession,
         cloud: config.cloud,
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
         enforceManagedModelDefaults: config.enforceManagedModelDefaults,
+        interactiveUser: config.interactiveUser,
         managedSettings: config.managedSettings
       });
       const {
@@ -1581,6 +1617,7 @@ class CopilotClient {
         enableCitations: config.enableCitations,
         enableFileChangeTracking: config.enableFileChangeTracking,
         sessionLimits: config.sessionLimits,
+        autopilot: config.autopilot,
         tools: config.tools?.map((tool) => ({
           name: tool.name,
           description: tool.description,
@@ -1589,7 +1626,8 @@ class CopilotClient {
           skipPermission: tool.skipPermission,
           defer: tool.defer,
           metadata: tool.metadata,
-          isTerminal: tool.isTerminal
+          isTerminal: tool.isTerminal,
+          namespace: tool.namespace
         })),
         toolSearch: config.toolSearch,
         imageGeneration: config.imageGeneration,
@@ -1645,22 +1683,25 @@ class CopilotClient {
         agent: config.agent,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        agentDirectories: config.agentDirectories,
+        hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
         instructionDirectories: config.instructionDirectories,
         disabledSkills: config.disabledSkills,
         disabledMcpServers: config.disabledMcpServers,
+        sandboxConfig: config.sandboxConfig,
         infiniteSessions: config.infiniteSessions,
         memory: config.memory,
         disableResume: config.suppressResumeEvent,
         continuePendingWork: config.continuePendingWork,
         gitHubToken: config.gitHubToken,
         gitHubTokenProviderRegistrationId,
-        remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
         featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
         enforceManagedModelDefaults: config.enforceManagedModelDefaults,
+        interactiveUser: config.interactiveUser,
         managedSettings: config.managedSettings,
         ...extensionOptions?.requestedEnvironmentVariables ? {
           requestedEnvironmentVariables: extensionOptions.requestedEnvironmentVariables
@@ -1724,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");
     }
@@ -1732,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,
@@ -1745,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) {
@@ -1754,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,
@@ -1766,7 +1829,14 @@ class CopilotClient {
           await rpc.host.dispose({ hostId });
         },
         (sessionId) => rpc.host.publishSession({ hostId, sessionId }),
-        () => rpc.host.listSessions({ hostId })
+        () => rpc.host.listSessions({ hostId }),
+        (sessionId) => rpc.host.unpublishSession({ hostId, sessionId }),
+        async (allowed) => {
+          await rpc.host.setSessionCreationPolicy({
+            hostId,
+            allowCreatingNewSessions: allowed
+          });
+        }
       );
     } catch (error) {
       this.hostExitCallbacks.delete(hostId);
@@ -1792,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,
@@ -1802,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);
@@ -1830,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,
@@ -1860,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
       });
@@ -2012,6 +2101,7 @@ class CopilotClient {
     let serverVersion;
     try {
       const connectParams = {
+        entra: this.options.entra,
         token: this.effectiveConnectionToken,
         supportedTaskKinds: ["agent", "client", "shell"]
       };
@@ -2026,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;
@@ -2312,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(
@@ -2426,7 +2516,13 @@ stderr: ${stderrOutput}`
       this.cliStartTimeout = setTimeout(() => {
         if (!resolved) {
           resolved = true;
-          reject(new Error("Timeout waiting for CLI server to start"));
+          reject(
+            new Error(
+              `Timeout waiting for CLI server to start
+stdout: ${stdout.trim().slice(-8192) || "(empty)"}
+stderr: ${this.stderrBuffer.trim().slice(-8192) || "(empty)"}`
+            )
+          );
         }
       }, 3e4);
     });
@@ -2494,9 +2590,6 @@ stderr: ${stderrOutput}`
     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}`);
     }
@@ -2519,6 +2612,9 @@ stderr: ${stderrOutput}`
     );
     this.attachConnectionHandlers();
     this.connection.listen();
+    this.ffiHost.configureUiThread(
+      this.connectionConfig.kind === "inprocess" && this.connectionConfig.runOnUiThread !== void 0
+    );
   }
   static getNapiPrebuildsFolder(entrypoint) {
     const arch = process.arch;
@@ -2561,6 +2657,9 @@ stderr: ${stderrOutput}`
 stderr: ${stderrOutput}` : ""}`
       );
       this.logDebug(`stdin pipe error: ${reason}`);
+      if (this.messageWriter) {
+        this.messageWriter.suppressWriteErrors = true;
+      }
       try {
         this.connection?.dispose();
       } catch {
@@ -2666,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/node_modules/@github/copilot-sdk/dist/cjs/copilotRequestHandler.js

@@ -98,7 +98,7 @@ class CopilotWebSocketForwarder extends CopilotWebSocketHandler {
   constructor(context) {
     super(context);
   }
-  sendRequestMessage(data) {
+  sendRequestMessage(data, _ctx) {
     if (this.#upstream?.readyState !== WebSocket.OPEN) {
       return;
     }
@@ -182,6 +182,7 @@ class CopilotRequestHandler {
       requestId: exchange.requestId,
       sessionId: exchange.sessionId,
       agentId: exchange.agentId,
+      agentInvocationId: exchange.agentInvocationId,
       parentAgentId: exchange.parentAgentId,
       interactionType: exchange.interactionType,
       transport: exchange.transport,
@@ -209,7 +210,10 @@ class CopilotRequestHandler {
       let cancelled;
       const clientSettled = (async () => {
         for await (const chunk of exchange.requestBody) {
-          await handler.sendRequestMessage(decodeFrame(chunk));
+          await handler.sendRequestMessage(decodeFrame(chunk.chunk ?? new Uint8Array()), {
+            ...ctx,
+            agentInvocationId: chunk.agentInvocationId
+          });
         }
         return "client-complete";
       })().catch((err) => {
@@ -309,7 +313,7 @@ function routeChunk(exchange, params) {
     return;
   }
   if (params.data && params.data.length > 0) {
-    exchange.pushChunk(decodeChunkData(params.data, !!params.binary));
+    exchange.pushChunk(decodeChunkData(params.data, !!params.binary), params.agentInvocationId);
   }
   if (params.end) {
     exchange.pushEnd();
@@ -319,6 +323,7 @@ class CopilotRequestExchange {
   requestId;
   sessionId;
   agentId;
+  agentInvocationId;
   parentAgentId;
   interactionType;
   method = "GET";
@@ -341,6 +346,7 @@ class CopilotRequestExchange {
   setContext(params) {
     this.sessionId = params.sessionId;
     this.agentId = params.agentId;
+    this.agentInvocationId = params.agentInvocationId;
     this.parentAgentId = params.parentAgentId;
     this.interactionType = params.interactionType;
     this.method = params.method;
@@ -361,8 +367,8 @@ class CopilotRequestExchange {
     return this.#cancelled;
   }
   // --- Request body feed (driven by the adapter as chunk frames arrive) ---
-  pushChunk(chunk) {
-    this.#push({ chunk });
+  pushChunk(chunk, agentInvocationId) {
+    this.#push({ chunk, agentInvocationId });
   }
   pushEnd() {
     this.#push({ end: true });
@@ -405,7 +411,7 @@ class CopilotRequestExchange {
             this.#drained = true;
             return { value: void 0, done: true };
           }
-          return { value: item.chunk ?? new Uint8Array(), done: false };
+          return { value: item, done: false };
         }
       })
     };
@@ -517,9 +523,11 @@ async function buildFetchRequest(exchange) {
 async function drainAsync(stream) {
   const parts = [];
   let total = 0;
-  for await (const chunk of stream) {
-    parts.push(chunk);
-    total += chunk.byteLength;
+  for await (const item of stream) {
+    if (item.chunk) {
+      parts.push(item.chunk);
+      total += item.chunk.byteLength;
+    }
   }
   if (parts.length === 0) {
     return new Uint8Array(0);

package/dist/node_modules/@github/copilot-sdk/dist/cjs/ffiRuntimeHost.js

@@ -80,6 +80,15 @@ function loadLibrary(libraryPath) {
       "size_t"
     ]),
     connectionClose: lib.func(`${SYMBOL_PREFIX}connection_close`, "bool", ["uint32"]),
+    connectionSetUiThreadHandler: lib.func(
+      `${SYMBOL_PREFIX}connection_set_ui_thread_handler`,
+      "bool",
+      ["uint32", "bool"]
+    ),
+    connectionRunUiAction: lib.func(`${SYMBOL_PREFIX}connection_run_ui_action`, "bool", [
+      "uint32",
+      "uint32"
+    ]),
     outboundCallbackType
   };
   loadedLibraryPath = libraryPath;
@@ -230,6 +239,21 @@ class FfiRuntimeHost {
       throw new Error("Failed to write a frame to the in-process runtime connection.");
     }
   }
+  configureUiThread(enabled) {
+    if (this.disposed || !this.lib.connectionSetUiThreadHandler(this.connectionId, enabled)) {
+      throw new Error("Failed to configure the in-process UI dispatcher.");
+    }
+  }
+  runUiAction(actionId) {
+    if (!Number.isInteger(actionId) || actionId < 0 || actionId > 4294967295) {
+      throw new RangeError("UI action ID must be an unsigned 32-bit integer.");
+    }
+    if (this.disposed || !this.lib.connectionRunUiAction(this.connectionId, actionId)) {
+      throw new Error(
+        "Native UI action is retired, already executed, or not running on the process main thread."
+      );
+    }
+  }
   /**
    * Native outbound (server→client) callback. koffi delivers it on the JS event loop
    * via a threadsafe function, so the frame is decoded and written straight to