@github/copilot-sdk-win32-x64 1.0.15 → 1.0.16

package/copilot-sdk/extension.js

@@ -4041,6 +4041,60 @@ import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve2 } f
 // src/sdk/nodejs/dist/generated/rpc.js
 function createServerRpc(connection) {
   return {
+    /** @experimental */
+    environments: {
+      /**
+       * Lists GitHub Mission Control environments visible to the authenticated identity. Does not require a running host and excludes host relay credentials.
+       *
+       * @param params Optional discovery filters supported by GitHub Mission Control.
+       *
+       * @returns Environments visible to the authenticated caller and matching the supplied filters.
+       */
+      list: async (params) => connection.sendRequest("environments.list", params),
+      /**
+       * Gets safe discovery information for a GitHub Mission Control environment without requiring a running host.
+       *
+       * @param params Identify a Mission Control environment to retrieve.
+       *
+       * @returns Safe discovery information for the requested environment.
+       */
+      get: async (params) => connection.sendRequest("environments.get", params),
+      /**
+       * Deletes a user-managed GitHub Mission Control environment. GitHub-managed environments cannot be deleted. Does not stop a running host, which may register again.
+       *
+       * @param params Identify a user-managed Mission Control environment to delete.
+       *
+       * @returns Acknowledgement that the requested environment was deleted.
+       */
+      delete: async (params) => connection.sendRequest("environments.delete", params)
+    },
+    /** @experimental */
+    host: {
+      /**
+       * Publishes an attached resident session for this listener's lifetime without copying it.
+       *
+       * @param params Publishes a resident session attached to the listener's owning connection.
+       *
+       * @returns The existing runtime identity and its resource on the listener.
+       */
+      publishSession: async (params) => connection.sendRequest("host.publishSession", params),
+      /**
+       * Starts a connection-owned AHP host with explicit localServer and/or githubEnvironment transports as a supervised SDK participant.
+       *
+       * @param params Starts a supervised AHP host with at least one explicitly selected transport.
+       *
+       * @returns Listener readiness, returned only after binding and the supervised participant's SDK handshake.
+       */
+      start: async (params) => connection.sendRequest("host.start", params),
+      /**
+       * Stops a listener owned by this SDK connection and joins its cleanup without deleting sessions.
+       *
+       * @param params Stops a connection-owned listener and joins its teardown.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      dispose: async (params) => connection.sendRequest("host.dispose", params)
+    },
     /**
      * Checks server responsiveness and returns protocol information.
      *
@@ -4873,6 +4927,45 @@ function createServerRpc(connection) {
 }
 function createInternalServerRpc(connection) {
   return {
+    /** @experimental */
+    host: {
+      /**
+       * Requests app-owned materialization over the owning SDK participant.
+       *
+       * @param params One application-owned session handoff, requested by the supervised hosting participant.
+       *
+       * @returns The resident session the application has materialized on its own connection.
+       */
+      createSession: async (params) => connection.sendRequest("host.createSession", params),
+      /**
+       * Releases app ownership retention after AHP detaches.
+       *
+       * @param params Ends one participation, not the application's session lifetime.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      releaseSession: async (params) => connection.sendRequest("host.releaseSession", params),
+      /**
+       * Resolves current authenticated credentials and remote-control policy only for the runtime-owned Mission Control hosting participant.
+       *
+       * @returns Private credentials delivered only to a runtime-owned Mission Control hosting participant.
+       */
+      getEnvironmentCredentials: async () => connection.sendRequest("host.getEnvironmentCredentials", {}),
+      /**
+       * Returns listener settings only to the supervised hosting participant over its SDK connection.
+       *
+       * @returns Normalized listener settings delivered only to the supervised hosting participant.
+       */
+      getConfiguration: async () => connection.sendRequest("host.getConfiguration", {}),
+      /**
+       * Reports a supervised hosting participant's bound AHP endpoint after its SDK handshake.
+       *
+       * @param params Readiness reported by the supervised hosting participant on its own SDK connection.
+       *
+       * @returns Empty acknowledgement for a completed host lifecycle operation.
+       */
+      ready: async (params) => connection.sendRequest("host.ready", params)
+    },
     /**
      * 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.
      *
@@ -4994,7 +5087,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Result of attempting to disable sandboxing for the current session.
        */
-      disableForSession: async (params) => connection.sendRequest("session.sandbox.disableForSession", { sessionId, ...params })
+      disableForSession: async (params) => connection.sendRequest("session.sandbox.disableForSession", { sessionId, ...params }),
+      /**
+       * Adds the path offered by a pending sandbox escalation permission request's sandboxPathGrant to the session's sandbox policy and approves the request, so the blocked operation re-runs inside the sandbox rather than outside it. The request is rejected unless the exact request is still pending, carries a sandboxPathGrant, and the grant still takes effect under the current managed policy. Does not persist the path; hosts that store sandbox settings save it themselves.
+       *
+       * @param params Request to accept the sandbox path grant offered on an active sandbox escalation permission prompt.
+       *
+       * @returns Result of accepting a sandbox path grant.
+       */
+      grantPathForRequest: async (params) => connection.sendRequest("session.sandbox.grantPathForRequest", { sessionId, ...params })
     },
     /**
      * Aborts the current agent turn.
@@ -6202,7 +6303,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns The selectable model entries and selection ids synthesized for the synchronized BYOK models.
        */
-      sync: async (params) => connection.sendRequest("session.provider.sync", { sessionId, ...params })
+      sync: async (params) => connection.sendRequest("session.provider.sync", { sessionId, ...params }),
+      /**
+       * Withdraws named host-managed models from the session's BYOK registry, leaving every other entry untouched. The scoped counterpart to `provider.sync`: a snapshot can only describe entries the caller knows about, so using it to remove one model silently withdraws rows registered by another source, such as a plugin calling `provider.add` at runtime. Naming what to remove leaves unrelated entries alone. Selection ids that are not registered are ignored, so withdrawal is idempotent. A provider is removed only when one of the withdrawn models was the last entry referencing it; a provider that simply has no models, which is the normal state while its rows are supplied by catalog discovery, is left in place.
+       *
+       * @param params Host-managed model selection ids to withdraw from the session's BYOK registry.
+       *
+       * @returns What the withdrawal actually removed from the registry.
+       */
+      withdraw: async (params) => connection.sendRequest("session.provider.withdraw", { sessionId, ...params })
     },
     /** @experimental */
     options: {
@@ -7455,6 +7564,11 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
   });
 }
 function registerClientGlobalApiHandlers(connection, handlers) {
+  connection.onNotification("host.exited", async (params) => {
+    const handler = handlers.host;
+    if (!handler) return;
+    await handler.exited(params);
+  });
   connection.onRequest("extensionLaunchProvider.resolve", async (params) => {
     const handler = handlers.extensionLaunchProvider;
     if (!handler) throw new Error("No extensionLaunchProvider client-global handler registered");
@@ -10568,6 +10682,42 @@ function assertWorkflowStepResult(value, key) {
   });
 }
 
+// src/sdk/nodejs/dist/host.js
+var AhpHost = class {
+  /** @internal */
+  constructor(info, disposeHost, publishHostSession) {
+    this.disposeHost = disposeHost;
+    this.publishHostSession = publishHostSession;
+    this.hostId = info.hostId;
+    this.url = info.url;
+    this.environmentId = info.environmentId;
+    this.token = info.token;
+    this.pid = info.pid;
+  }
+  disposeHost;
+  publishHostSession;
+  hostId;
+  /** Local WebSocket URL. Absent when only the GitHub environment is enabled. */
+  url;
+  /** Mission Control environment ID, when GitHub hosting is enabled. */
+  environmentId;
+  /** Connection token, when required by the listener. Treat this value as a secret. */
+  token;
+  /** Legacy separate host process ID. Absent for in-process listeners; use dispose() to stop. */
+  pid;
+  /** Ask the runtime to stop the listener and await its cleanup, on every call. */
+  dispose() {
+    return this.disposeHost();
+  }
+  /** Publish an existing session attached to this client, until this listener stops. */
+  publishSession(sessionId) {
+    return this.publishHostSession(sessionId);
+  }
+  async [Symbol.asyncDispose]() {
+    await this.dispose();
+  }
+};
+
 // src/sdk/nodejs/dist/runtimeArtifacts.js
 import {
   chmodSync,
@@ -10914,6 +11064,57 @@ var ToolSet = class {
 // src/sdk/nodejs/dist/client.js
 var MIN_PROTOCOL_VERSION = 3;
 var RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
+function createMessageConnection(reader, writer) {
+  let dispatch;
+  let finishDrain;
+  let drained;
+  let disposed = false;
+  const barrier = { jsonrpc: "2.0", method: "$/sdkDrain" };
+  const connection = (0, import_node3.createMessageConnection)(
+    {
+      onError: reader.onError,
+      onClose: reader.onClose,
+      onPartialMessage: reader.onPartialMessage,
+      listen: (callback) => {
+        dispatch = callback;
+        return reader.listen(callback);
+      },
+      dispose: () => reader.dispose()
+    },
+    writer,
+    void 0,
+    {
+      messageStrategy: {
+        handleMessage: (message, next) => {
+          if (message === barrier) {
+            finishDrain?.();
+          } else {
+            next(message);
+          }
+        }
+      }
+    }
+  );
+  connection.onDispose(() => {
+    disposed = true;
+    finishDrain?.();
+  });
+  return Object.assign(connection, {
+    drain: () => {
+      if (!drained) {
+        drained = new Promise((resolve22) => {
+          finishDrain = resolve22;
+          if (disposed || !dispatch) {
+            resolve22();
+          } else {
+            dispatch(barrier);
+          }
+        });
+      }
+      return drained;
+    }
+  });
+}
 async function withTimeout(promise, timeoutMs, message) {
   let timeout;
   try {
@@ -11100,6 +11301,9 @@ var CopilotClient = class _CopilotClient {
   /** Shared in-flight start; concurrent callers await it instead of spawning another CLI. */
   startPromise = null;
   sessions = /* @__PURE__ */ new Map();
+  hostExitCallbacks = /* @__PURE__ */ new Map();
+  hostSessionFactories = /* @__PURE__ */ new Map();
+  hostHandoffs = /* @__PURE__ */ new Map();
   stderrBuffer = "";
   // Captures CLI stderr for error messages
   /** Resolved connection mode chosen in the constructor. */
@@ -11391,6 +11595,11 @@ var CopilotClient = class _CopilotClient {
   }
   setupClientGlobalHandlers() {
     const handlers = {};
+    handlers.host = {
+      exited: async (exit) => {
+        this.handleHostExit(exit);
+      }
+    };
     handlers.extensionLaunchProvider = this.extensionLaunchProvider;
     if (this.requestHandler) {
       this.requestAdapter = createCopilotRequestAdapter(this.requestHandler, () => {
@@ -11544,7 +11753,8 @@ var CopilotClient = class _CopilotClient {
    * 1. Closes all active sessions (releases in-memory resources)
    * 2. Requests runtime shutdown for SDK-owned CLI processes
    * 3. Closes the JSON-RPC connection
-   * 4. Terminates the CLI server process (if spawned by this client)
+   * 4. Signals EOF to an owned stdio process and waits for host cleanup, then
+   *    terminates the process if it does not exit within the shutdown timeout
    *
    * Note: session data on disk is preserved, so sessions can be resumed later.
    * To permanently remove session data before stopping, call
@@ -11662,7 +11872,23 @@ var CopilotClient = class _CopilotClient {
     }
     if (this.cliProcess && !this.isExternalServer) {
       const child = this.cliProcess;
-      this.cliProcess = null;
+      if (this.connectionConfig.kind === "stdio" && child.stdin && child.exitCode == null && child.signalCode == null) {
+        const gracefulExitStart = Date.now();
+        try {
+          child.stdin.end();
+          const exited = await waitForChildExit(child, RUNTIME_SHUTDOWN_TIMEOUT_MS);
+          this.logDebugTiming(
+            exited ? "CopilotClient.stop graceful stdio exit complete" : "CopilotClient.stop graceful stdio exit timed out; terminating child",
+            gracefulExitStart
+          );
+        } catch (error) {
+          errors.push(
+            new Error(
+              `Failed to close CLI stdin: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      }
       try {
         if (child.exitCode == null && child.signalCode == null) {
           child.kill();
@@ -11680,6 +11906,10 @@ var CopilotClient = class _CopilotClient {
             `Failed to kill CLI process: ${error instanceof Error ? error.message : String(error)}`
           )
         );
+      } finally {
+        if (this.cliProcess === child) {
+          this.cliProcess = null;
+        }
       }
     }
     if (this.ffiHost) {
@@ -11703,6 +11933,7 @@ var CopilotClient = class _CopilotClient {
     this.runtimePort = null;
     this.stderrBuffer = "";
     this.processExitPromise = null;
+    this.disconnectHosts();
     return errors;
   }
   /**
@@ -11747,6 +11978,7 @@ var CopilotClient = class _CopilotClient {
    */
   async forceStop() {
     this.forceStopping = true;
+    this.disconnectHosts();
     for (const session of this.sessions.values()) {
       session._markDisconnected();
     }
@@ -12046,6 +12278,7 @@ var CopilotClient = class _CopilotClient {
       const response = await this.connection.sendRequest("session.create", {
         ...await getTraceContext(this.onGetTraceContext),
         model: config.model,
+        allowedModels: config.allowedModels,
         sessionId: localSessionId,
         clientName: config.clientName,
         reasoningEffort: config.reasoningEffort,
@@ -12176,6 +12409,11 @@ var CopilotClient = class _CopilotClient {
       }
       throw e;
     }
+    for (const entry of this.hostHandoffs.values()) {
+      if (entry.requestedSessionId === session.sessionId) {
+        entry.configs.set(session, config);
+      }
+    }
     return session;
   }
   /**
@@ -12282,6 +12520,7 @@ var CopilotClient = class _CopilotClient {
     }
     try {
       const response = await this.connection.sendRequest("session.resume", {
+        allowedModels: config.allowedModels,
         ...await getTraceContext(this.onGetTraceContext),
         sessionId,
         clientName: config.clientName,
@@ -12410,8 +12649,205 @@ var CopilotClient = class _CopilotClient {
       }
       throw e;
     }
+    for (const entry of this.hostHandoffs.values()) {
+      if (entry.requestedSessionId === session.sessionId) {
+        entry.configs.set(session, { ...config, sessionId });
+      }
+    }
     return session;
   }
+  /**
+   * Start a complete AHP listener hosted in-process by this runtime.
+   *
+   * This connection owns the host. Disposing it or disconnecting the client
+   * stops the listener without deleting sessions. The host uses a separate
+   * SDK connection to the same runtime, not another runtime process.
+   * Only one AHP host may own the catalog in an effective Copilot home
+   * at a time. Other SDK clients and sessions remain usable in that home.
+   * Select localServer, githubEnvironment, or both. An empty localServer
+   * selects 127.0.0.1 on an available port. `onExit` runs at most once; owner disconnection cannot
+   * acknowledge listener cleanup over the disconnected transport.
+   *
+   * @experimental
+   */
+  async startAhpHost(options) {
+    if (!options?.localServer && !options?.githubEnvironment) {
+      throw new Error("At least one of localServer or githubEnvironment is required");
+    }
+    if (this.state !== "connected") {
+      await this.start();
+    }
+    const rpc = this.rpc;
+    const hostId = randomUUID();
+    const {
+      localServer,
+      githubEnvironment,
+      onExit,
+      createSession,
+      resumeSession,
+      onSessionReleased
+    } = options;
+    if (createSession || resumeSession) {
+      this.hostSessionFactories.set(hostId, {
+        createSession,
+        resumeSession,
+        onSessionReleased
+      });
+    }
+    if (onExit) {
+      this.hostExitCallbacks.set(hostId, onExit);
+    }
+    try {
+      const info = await rpc.host.start({
+        hostId,
+        localServer,
+        githubEnvironment,
+        sessionFactory: createSession ? true : void 0,
+        resumeFactory: resumeSession ? true : void 0
+      });
+      return new AhpHost(
+        info,
+        async () => {
+          await rpc.host.dispose({ hostId });
+        },
+        (sessionId) => rpc.host.publishSession({ hostId, sessionId })
+      );
+    } catch (error) {
+      this.hostExitCallbacks.delete(hostId);
+      this.releaseHostSessions(hostId);
+      throw error;
+    }
+  }
+  handleHostExit(exit) {
+    this.releaseHostSessions(exit.hostId);
+    const onExit = this.hostExitCallbacks.get(exit.hostId);
+    if (onExit) {
+      this.hostExitCallbacks.delete(exit.hostId);
+      const reportError = (error) => {
+        console.error("AHP host exit callback failed", { hostId: exit.hostId, error });
+      };
+      try {
+        void Promise.resolve(onExit(exit)).catch(reportError);
+      } catch (error) {
+        reportError(error);
+      }
+    }
+  }
+  disconnectHosts() {
+    for (const hostId of /* @__PURE__ */ new Set([
+      ...this.hostExitCallbacks.keys(),
+      ...this.hostSessionFactories.keys()
+    ])) {
+      this.handleHostExit({
+        hostId,
+        reason: "ownerDisconnected",
+        error: "Owner connection closed; runtime cleanup cannot be acknowledged on this connection."
+      });
+    }
+  }
+  releaseHostSessions(hostId) {
+    this.hostSessionFactories.delete(hostId);
+    for (const [handoffId, entry] of this.hostHandoffs) {
+      if (entry.hostId === hostId) this.releaseHostSession(handoffId);
+    }
+  }
+  releaseHostSession(handoffId) {
+    const entry = this.hostHandoffs.get(handoffId);
+    if (!entry) return;
+    this.hostHandoffs.delete(handoffId);
+    entry.released = true;
+    entry.configs.clear();
+    entry.controller.abort();
+    if (entry.session) this.notifyHostSessionReleased(entry);
+  }
+  notifyHostSessionReleased(entry) {
+    const { session, onReleased } = entry;
+    entry.session = void 0;
+    if (session && onReleased) {
+      try {
+        void Promise.resolve(onReleased(session)).catch(() => {
+          console.error("AHP session release callback failed");
+        });
+      } catch {
+        console.error("AHP session release callback failed");
+      }
+    }
+  }
+  async createHostSession(params) {
+    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 entry = {
+      hostId: params.hostId,
+      requestedSessionId: params.config.sessionId,
+      controller: new AbortController(),
+      configs: /* @__PURE__ */ new Map(),
+      released: false,
+      onReleased: options.onSessionReleased
+    };
+    this.hostHandoffs.set(params.handoffId, entry);
+    const { configDir, ...config } = params.config;
+    if (configDir !== void 0) config.configDirectory = configDir;
+    const expected = structuredClone(config);
+    const cancelled = new Promise((_resolve, reject) => {
+      entry.controller.signal.addEventListener(
+        "abort",
+        () => {
+          reject(new Error("AHP session handoff ended"));
+        },
+        { once: true }
+      );
+    });
+    const materialized = Promise.resolve().then(() => {
+      if (params.resume) {
+        const { sessionId, ...resumeConfig } = config;
+        if (!sessionId) throw new Error("AHP resume requires sessionId");
+        return options.resumeSession({
+          sessionId,
+          config: resumeConfig,
+          signal: entry.controller.signal
+        });
+      }
+      return options.createSession({
+        config,
+        signal: entry.controller.signal
+      });
+    }).then((session) => {
+      entry.session = session;
+      const actual = entry.configs.get(session);
+      entry.configs.clear();
+      if (entry.released) {
+        this.notifyHostSessionReleased(entry);
+        throw new Error("AHP session handoff ended");
+      }
+      if (this.sessions.get(session.sessionId) !== session || session.sessionId !== expected.sessionId) {
+        throw new Error(
+          "AHP callback must return the requested session from this client"
+        );
+      }
+      const contains = (value, required) => {
+        if (required && typeof required === "object" && !Array.isArray(required)) {
+          return !!value && typeof value === "object" && Object.entries(required).every(
+            ([key, child]) => contains(value[key], child)
+          );
+        }
+        return JSON.stringify(value) === JSON.stringify(required);
+      };
+      if ((!params.resume || actual !== void 0) && !contains(actual, expected)) {
+        throw new Error(
+          "AHP callback must preserve the supplied session configuration"
+        );
+      }
+      return { sessionId: session.sessionId };
+    });
+    try {
+      return await Promise.race([materialized, cancelled]);
+    } catch (error) {
+      this.releaseHostSession(params.handoffId);
+      throw error;
+    }
+  }
   /**
    * Sends a ping request to the server to verify connectivity.
    *
@@ -12951,8 +13387,13 @@ stderr: ${stderrOutput}`
       case "inprocess":
         return this.connectViaFfi();
       case "tcp":
-      case "uri":
         return this.connectViaTcp();
+      case "uri": {
+        const { host, port } = this.parseCliUrl(this.connectionConfig.url);
+        this.actualHost = host;
+        this.runtimePort = port;
+        return this.connectViaTcp();
+      }
     }
   }
   /** Starts the in-process FFI runtime with SDK-managed typed options. */
@@ -13011,7 +13452,7 @@ stderr: ${stderrOutput}`
       throw new Error("In-process FFI runtime host not started");
     }
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.ffiHost.sendStream);
-    this.connection = (0, import_node3.createMessageConnection)(
+    this.connection = createMessageConnection(
       new import_node3.StreamMessageReader(this.ffiHost.receiveStream),
       this.messageWriter
     );
@@ -13065,7 +13506,7 @@ stderr: ${stderrOutput}` : ""}`
       }
     });
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.cliProcess.stdin);
-    this.connection = (0, import_node3.createMessageConnection)(
+    this.connection = createMessageConnection(
       new import_node3.StreamMessageReader(this.cliProcess.stdout),
       this.messageWriter
     );
@@ -13080,7 +13521,7 @@ stderr: ${stderrOutput}` : ""}`
       throw new Error("CLI child process was unexpectedly started in parent process mode");
     }
     this.messageWriter = new TeardownResilientStreamMessageWriter(process.stdout);
-    this.connection = (0, import_node3.createMessageConnection)(
+    this.connection = createMessageConnection(
       new import_node3.StreamMessageReader(process.stdin),
       this.messageWriter
     );
@@ -13103,7 +13544,7 @@ stderr: ${stderrOutput}` : ""}`
       this.socket.connect(this.runtimePort, this.actualHost, () => {
         clearTimeout(connectionTimeout);
         this.messageWriter = new TeardownResilientStreamMessageWriter(this.socket);
-        this.connection = (0, import_node3.createMessageConnection)(
+        this.connection = createMessageConnection(
           new import_node3.StreamMessageReader(this.socket),
           this.messageWriter
         );
@@ -13160,6 +13601,18 @@ stderr: ${stderrOutput}` : ""}`
         (params, token) => confirmation.confirm(params, token)
       );
     }
+    this.connection.onRequest(
+      "host.materializeSession",
+      (params) => this.createHostSession(params)
+    );
+    this.connection.onNotification(
+      "host.sessionReleased",
+      (params) => {
+        if (this.hostHandoffs.get(params.handoffId)?.hostId === params.hostId) {
+          this.releaseHostSession(params.handoffId);
+        }
+      }
+    );
     this.connection.onRequest(
       "hooks.invoke",
       async (params) => {
@@ -13167,20 +13620,27 @@ stderr: ${stderrOutput}` : ""}`
       }
     );
     const connection = this.connection;
+    const messageWriter = this.messageWriter;
     const markDisconnected = () => {
       if (this.connection !== connection) {
+        connection.dispose();
         return;
       }
       this.connectionClosed = true;
       this.state = "disconnected";
+      this.disconnectHosts();
       for (const session of this.sessions.values()) {
         session._markDisconnected();
       }
       this.sessions.clear();
       this.githubTokenProviders.clear();
       this.requestAdapter?.cancelPending();
+      connection.dispose();
     };
-    this.connection.onClose(markDisconnected);
+    this.connection.onClose(() => {
+      if (messageWriter) messageWriter.suppressWriteErrors = true;
+      void connection.drain().then(markDisconnected);
+    });
     this.connection.onError(() => {
       if (this.connection === connection) {
         this.state = "disconnected";