@github/copilot-sdk 1.0.16-preview.0 → 1.0.17-preview.0

package/README.md

@@ -9,8 +9,8 @@ To use the SDK, you'll need:
 - Node.js ^20.19.0 or >=22.12.0
 
 The SDK uses an optional `@github/copilot-sdk-<platform>` package containing the
-Copilot CLI runtime for the host platform. These packages are built from
-verified `github/copilot-cli` release assets when the SDK is published, so
+Copilot CLI runtime for the host platform. These packages contain the verified
+runtime artifacts for that SDK release, so
 starting the SDK performs no runtime download. Set `COPILOT_CLI_PATH` to use an
 existing installation instead.
 
@@ -20,6 +20,10 @@ replaces both with the CLI version published for that snapshot.
 
 `npm run pack:release` builds the main package and all platform packages. Set
 `COPILOT_CLI_DOWNLOAD_BASE_URL` to use a release mirror while packaging.
+Standalone source builds acquire stable/prerelease runtime assets from
+`github/copilot-cli` at `v<runtime-version>`, and canonical unstable assets from
+`github/copilot-sdk` at `runtime-<runtime-version>`. Both checksum and package
+downloads use that release location; mirror overrides retain the same tag scheme.
 Release workflows instead set `COPILOT_SDK_RUNTIME_PACKAGE_DIR` to a directory
 containing validated runtime npm package roots named for all eight platforms.
 This keeps `COPILOT_CLI_USE_NPM_PACKAGE` false and embeds those runtime files in
@@ -368,6 +372,12 @@ Initial acquisition runs during session creation or resume. Cancellation, provid
 ##### `resumeSession(sessionId: string, config?: ResumeSessionConfig): Promise<CopilotSession>`
 
 Resume an existing session. Returns the session with `workspacePath` populated if infinite sessions were enabled.
+`allowTranscriptRecovery` controls whether the runtime may repair a damaged transcript during
+resume. It defaults to `true` in all modes; set it to `false` to reject recovery.
+When repair occurs, inspect `session.transcriptRecovery` for the planned backup path,
+invalid line numbers, and whether `session.start` was moved. The backup
+is written when the repaired transcript is next appended, not during resume. Disabling recovery
+still permits adding a missing newline after an intact final record; it rejects torn tails.
 
 ##### `ping(message?: string): Promise<{ message: string; timestamp: string }>`
 

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.90-6";
+const COPILOT_CLI_VERSION = "1.0.92-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

@@ -282,6 +282,7 @@ class CopilotClient {
   requestAdapter = null;
   messageWriter = null;
   connectionClosed = false;
+  connectionEpoch = 0;
   socket = null;
   runtimePort = null;
   actualHost = "localhost";
@@ -691,6 +692,7 @@ class CopilotClient {
   }
   async doStart() {
     this.forceStopping = false;
+    this.connectionEpoch++;
     this.connectionClosed = false;
     this.processTransportError = null;
     this.state = "connecting";
@@ -726,6 +728,9 @@ class CopilotClient {
       if (this.requestHandler) {
         await this.connection.sendRequest("llmInference.setProvider", {});
       }
+      if (this.connectionClosed) {
+        throw new Error("CLI server connection closed during startup");
+      }
       this.state = "connected";
     } catch (error) {
       const startupError = this.processTransportError ?? error;
@@ -845,10 +850,23 @@ class CopilotClient {
       this.socket = null;
       try {
         if (!socket.destroyed) {
-          await new Promise((resolve2) => {
-            socket.once("close", () => resolve2());
-            socket.end();
-          });
+          let timeout;
+          try {
+            await new Promise((resolve2) => {
+              socket.once("close", () => resolve2());
+              if (this.connectionClosed) {
+                socket.destroy();
+              } else {
+                timeout = setTimeout(
+                  () => socket.destroy(),
+                  RUNTIME_SHUTDOWN_TIMEOUT_MS
+                );
+                socket.end();
+              }
+            });
+          } finally {
+            if (timeout !== void 0) clearTimeout(timeout);
+          }
         }
       } catch (error) {
         errors.push(
@@ -1511,6 +1529,7 @@ class CopilotClient {
         allowedModels: config.allowedModels,
         ...await (0, import_telemetry.getTraceContext)(this.onGetTraceContext),
         sessionId,
+        allowTranscriptRecovery: config.allowTranscriptRecovery,
         clientName: config.clientName,
         model: config.model,
         reasoningEffort: config.reasoningEffort,
@@ -1617,10 +1636,11 @@ class CopilotClient {
           }
         }
       }
-      const { workspacePath, capabilities, openCanvases } = response;
+      const { workspacePath, capabilities, openCanvases, transcriptRecovery } = response;
       session["_workspacePath"] = workspacePath;
       session.setCapabilities(capabilities);
       session.setOpenCanvases(openCanvases ?? []);
+      session.setTranscriptRecovery(transcriptRecovery);
       if (config.onMcpAuthRequest) {
         await this.connection.sendRequest("session.eventLog.registerInterest", {
           sessionId,
@@ -2609,8 +2629,13 @@ stderr: ${stderrOutput}` : ""}`
     );
     const connection = this.connection;
     const messageWriter = this.messageWriter;
+    const cliProcess = this.isExternalServer ? null : this.cliProcess;
+    const connectionEpoch = this.connectionEpoch;
+    const isCurrentConnection = () => connectionEpoch === this.connectionEpoch && this.connection === connection && (cliProcess === null || this.cliProcess === cliProcess);
+    let disconnecting = false;
+    let exitFallback;
     const markDisconnected = () => {
-      if (this.connection !== connection) {
+      if (!isCurrentConnection()) {
         connection.dispose();
         return;
       }
@@ -2624,13 +2649,48 @@ stderr: ${stderrOutput}` : ""}`
       this.githubTokenProviders.clear();
       this.requestAdapter?.cancelPending();
       connection.dispose();
+      this.socket?.destroy();
+      this.connection = null;
+      this.messageWriter = null;
+      this._rpc = null;
+      this._internalRpc = null;
+      this.modelsCache = null;
     };
-    this.connection.onClose(() => {
+    const disconnectAfterDrain = () => {
+      if (exitFallback !== void 0) {
+        clearTimeout(exitFallback);
+        exitFallback = void 0;
+      }
+      if (!isCurrentConnection()) {
+        connection.dispose();
+        return;
+      }
+      if (disconnecting) return;
+      disconnecting = true;
+      this.connectionClosed = true;
       if (messageWriter) messageWriter.suppressWriteErrors = true;
       void connection.drain().then(markDisconnected);
-    });
+    };
+    this.connection.onClose(disconnectAfterDrain);
+    if (cliProcess) {
+      cliProcess.once("exit", () => {
+        if (!isCurrentConnection()) {
+          connection.dispose();
+          return;
+        }
+        if (disconnecting) return;
+        if (this.socket) {
+          disconnectAfterDrain();
+          return;
+        }
+        this.connectionClosed = true;
+        if (messageWriter) messageWriter.suppressWriteErrors = true;
+        exitFallback = setTimeout(disconnectAfterDrain, RUNTIME_SHUTDOWN_TIMEOUT_MS);
+        exitFallback.unref();
+      });
+    }
     this.connection.onError(() => {
-      if (this.connection === connection) {
+      if (connectionEpoch === this.connectionEpoch && this.connection === connection) {
         this.state = "disconnected";
       }
     });

package/dist/cjs/ffiRuntimeHost.js

@@ -208,7 +208,7 @@ class FfiRuntimeHost {
       );
       if (!this.connectionId) {
         this.unregisterCallback();
-        this.lib.hostShutdown(this.serverId);
+        await this.shutdownHost();
         this.serverId = 0;
         throw new Error("copilot_runtime_connection_open failed.");
       }
@@ -217,7 +217,7 @@ class FfiRuntimeHost {
     } finally {
       this.starting = false;
       if (this.disposed) {
-        void this.tryFinalizeCleanup();
+        await this.tryFinalizeCleanup();
       }
     }
   }
@@ -256,6 +256,17 @@ class FfiRuntimeHost {
       );
     }
   }
+  shutdownHost() {
+    return new Promise((resolvePromise, rejectPromise) => {
+      this.lib.hostShutdown.async(this.serverId, (error, result) => {
+        if (error) {
+          rejectPromise(error);
+        } else {
+          resolvePromise(result);
+        }
+      });
+    });
+  }
   unregisterCallback() {
     if (this.outboundCallback === void 0) {
       return true;
@@ -328,7 +339,7 @@ class FfiRuntimeHost {
       }
       if (this.serverId) {
         try {
-          if (!this.lib.hostShutdown(this.serverId)) {
+          if (!await this.shutdownHost()) {
             console.error(
               `In-process FFI host shutdown did not recognize server ${this.serverId}.`
             );

package/dist/cjs/generated/rpc.js

@@ -647,15 +647,45 @@ function createServerRpc(connection) {
     /** @experimental */
     managedSettings: {
       /**
-       * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session.
+       * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session. `managedSettings.resolve` returns the same device settings together with the account's server policy.
        *
        * @returns Validated device-managed settings discovered before a session exists.
        */
       read: async () => connection.sendRequest("managedSettings.read", {}),
       /**
-       * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
+       * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should call `managedSettings.resolve` or start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
        */
-      clearCache: async () => connection.sendRequest("managedSettings.clearCache", {})
+      clearCache: async () => connection.sendRequest("managedSettings.clearCache", {}),
+      /**
+       * Resolves the effective enterprise managed settings without a session, from the device channel and, when an account is available, the account's server policy through the same per-account cache sessions use. A cached server policy less than an hour old is used without a fetch; otherwise the policy is fetched, and when the fetch fails a cached policy up to 24 hours old is used instead, unless `forceRemoteSettingsRefresh` requires a live fetch. With no account requested or signed in, it reports device policy only; signing out removes the account's cached policy. It can fetch server policy over the network when the cache is stale, so call it off latency-critical paths such as startup rather than before listing models. The policy helper is not run. `layers` lists each channel's document before merging, and `values` and `meta` carry typed effective values and their lock state for the keys typed so far.
+       *
+       * @param params Optional opaque account selection or GitHub token whose managed settings are resolved.
+       *
+       * @returns Effective enterprise managed settings for an account, resolved without a session.
+       */
+      resolve: async (params) => connection.sendRequest("managedSettings.resolve", params),
+      /**
+       * Returns the managed-settings authoring JSON schema with descriptive `x-composition` annotations aligned with the shared settings-engine vocabulary. These annotations are not a complete runtime composition contract: model, effortLevel, and contextTier remain coupled. Use `managedSettings.compose` for the runtime's effective result. Performs no I/O.
+       *
+       * @returns The authoring JSON schema for managed settings recognized by this runtime.
+       */
+      schema: async () => connection.sendRequest("managedSettings.schema", {}),
+      /**
+       * Validates a candidate managed-settings document the way the runtime validates delivered policy, without applying it. Reports errors that would reject the document, warnings for content the runtime ignores, and the canonical document it would apply. Document text nested more than 64 levels deep is rejected. Performs no I/O.
+       *
+       * @param params A candidate managed-settings document to validate without applying it.
+       *
+       * @returns Result of validating a managed-settings document.
+       */
+      validate: async (params) => connection.sendRequest("managedSettings.validate", params),
+      /**
+       * Merges candidate managed-settings documents for the device, server, and policy-helper channels into the effective settings the runtime would enforce on this host, using the same precedence and composition rules as live resolution, without applying them. Like live resolution, a server's advisory sandbox force-enable is declined on a host that cannot run the sandbox. Does not fetch policy or read policy files, but may perform blocking OS or subprocess probes for sandbox support. Preview documents are limited to 1 MiB and 64 levels of nesting.
+       *
+       * @param params Candidate managed-settings documents to merge without applying them.
+       *
+       * @returns The effective managed settings the runtime would enforce for the given documents, in the same shape `managedSettings.resolve` returns.
+       */
+      compose: async (params) => connection.sendRequest("managedSettings.compose", params)
     },
     /** @experimental */
     runtime: {
@@ -2103,6 +2133,12 @@ function createSessionRpc(connection, sessionId) {
        * @returns Feature detection and hard polling limits for the EXPERIMENTAL session connector API.
        */
       getCapabilities: async () => connection.sendRequest("session.connectors.getCapabilities", { sessionId }),
+      /**
+       * Returns the session account selection, or null.
+       *
+       * @returns Session account selection, or null.
+       */
+      getAccount: async () => connection.sendRequest("session.connectors.getAccount", { sessionId }),
       /**
        * Returns authoritative session Connector state from current availability, pinned account selection, cached catalog, and live MCP projection without performing a Connector service request.
        *
@@ -2171,7 +2207,7 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Waits for the live session's in-flight managed-settings application, then returns the retained effective snapshot used by runtime enforcement and by `session.managed_settings_resolved`. It does not perform another account, device, or server resolution, and rejects when resolution has not produced a snapshot.
        *
-       * @returns Enterprise managed-settings resolution: the effective managed settings the session applied and which channels contributed, so SDK clients can show users what is enterprise-managed. Fires whenever managed policy is (re)applied — at session start, on resume, and on account switch. This is an ephemeral live snapshot (delivered to subscribers but not persisted to the session event log), because at session start it resolves before `session.start` is emitted. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively across device, server, policy-helper, and SDK-client layers. The account-scoped `getManagedSettings()` API does not include session-local client injection. Marked experimental while the managed-settings surface stabilizes.
+       * @returns Effective enterprise managed settings and contributing channels. Session events report applied policy; sessionless resolve reports an account/device snapshot, and compose reports a non-applying preview of candidate documents. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively. Session-local SDK-client policy is included only in session results. Marked experimental while the managed-settings surface stabilizes.
        */
       get: async () => connection.sendRequest("session.managedSettings.get", { sessionId })
     },

package/dist/cjs/session.js

@@ -254,6 +254,7 @@ class CopilotSession {
   sessionId;
   connection;
   _workspacePath;
+  _transcriptRecovery;
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
@@ -443,6 +444,14 @@ class CopilotSession {
   get workspacePath() {
     return this._workspacePath;
   }
+  /** Recovery observed while loading this session; undefined on a clean resume. */
+  get transcriptRecovery() {
+    return this._transcriptRecovery;
+  }
+  /** @internal */
+  setTranscriptRecovery(recovery) {
+    this._transcriptRecovery = recovery;
+  }
   /**
    * Host capabilities reported when the session was created or resumed.
    * Use this to check feature support before calling capability-gated APIs.

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.90-6";
+export declare const COPILOT_CLI_VERSION = "1.0.92-0";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.90-6";
+const COPILOT_CLI_VERSION = "1.0.92-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.d.ts

@@ -10,6 +10,7 @@ export declare class CopilotClient {
     private requestAdapter;
     private messageWriter;
     private connectionClosed;
+    private connectionEpoch;
     private socket;
     private runtimePort;
     private actualHost;

package/dist/client.js

@@ -262,6 +262,7 @@ class CopilotClient {
   requestAdapter = null;
   messageWriter = null;
   connectionClosed = false;
+  connectionEpoch = 0;
   socket = null;
   runtimePort = null;
   actualHost = "localhost";
@@ -671,6 +672,7 @@ class CopilotClient {
   }
   async doStart() {
     this.forceStopping = false;
+    this.connectionEpoch++;
     this.connectionClosed = false;
     this.processTransportError = null;
     this.state = "connecting";
@@ -706,6 +708,9 @@ class CopilotClient {
       if (this.requestHandler) {
         await this.connection.sendRequest("llmInference.setProvider", {});
       }
+      if (this.connectionClosed) {
+        throw new Error("CLI server connection closed during startup");
+      }
       this.state = "connected";
     } catch (error) {
       const startupError = this.processTransportError ?? error;
@@ -825,10 +830,23 @@ class CopilotClient {
       this.socket = null;
       try {
         if (!socket.destroyed) {
-          await new Promise((resolve2) => {
-            socket.once("close", () => resolve2());
-            socket.end();
-          });
+          let timeout;
+          try {
+            await new Promise((resolve2) => {
+              socket.once("close", () => resolve2());
+              if (this.connectionClosed) {
+                socket.destroy();
+              } else {
+                timeout = setTimeout(
+                  () => socket.destroy(),
+                  RUNTIME_SHUTDOWN_TIMEOUT_MS
+                );
+                socket.end();
+              }
+            });
+          } finally {
+            if (timeout !== void 0) clearTimeout(timeout);
+          }
         }
       } catch (error) {
         errors.push(
@@ -1491,6 +1509,7 @@ class CopilotClient {
         allowedModels: config.allowedModels,
         ...await getTraceContext(this.onGetTraceContext),
         sessionId,
+        allowTranscriptRecovery: config.allowTranscriptRecovery,
         clientName: config.clientName,
         model: config.model,
         reasoningEffort: config.reasoningEffort,
@@ -1597,10 +1616,11 @@ class CopilotClient {
           }
         }
       }
-      const { workspacePath, capabilities, openCanvases } = response;
+      const { workspacePath, capabilities, openCanvases, transcriptRecovery } = response;
       session["_workspacePath"] = workspacePath;
       session.setCapabilities(capabilities);
       session.setOpenCanvases(openCanvases ?? []);
+      session.setTranscriptRecovery(transcriptRecovery);
       if (config.onMcpAuthRequest) {
         await this.connection.sendRequest("session.eventLog.registerInterest", {
           sessionId,
@@ -2589,8 +2609,13 @@ stderr: ${stderrOutput}` : ""}`
     );
     const connection = this.connection;
     const messageWriter = this.messageWriter;
+    const cliProcess = this.isExternalServer ? null : this.cliProcess;
+    const connectionEpoch = this.connectionEpoch;
+    const isCurrentConnection = () => connectionEpoch === this.connectionEpoch && this.connection === connection && (cliProcess === null || this.cliProcess === cliProcess);
+    let disconnecting = false;
+    let exitFallback;
     const markDisconnected = () => {
-      if (this.connection !== connection) {
+      if (!isCurrentConnection()) {
         connection.dispose();
         return;
       }
@@ -2604,13 +2629,48 @@ stderr: ${stderrOutput}` : ""}`
       this.githubTokenProviders.clear();
       this.requestAdapter?.cancelPending();
       connection.dispose();
+      this.socket?.destroy();
+      this.connection = null;
+      this.messageWriter = null;
+      this._rpc = null;
+      this._internalRpc = null;
+      this.modelsCache = null;
     };
-    this.connection.onClose(() => {
+    const disconnectAfterDrain = () => {
+      if (exitFallback !== void 0) {
+        clearTimeout(exitFallback);
+        exitFallback = void 0;
+      }
+      if (!isCurrentConnection()) {
+        connection.dispose();
+        return;
+      }
+      if (disconnecting) return;
+      disconnecting = true;
+      this.connectionClosed = true;
       if (messageWriter) messageWriter.suppressWriteErrors = true;
       void connection.drain().then(markDisconnected);
-    });
+    };
+    this.connection.onClose(disconnectAfterDrain);
+    if (cliProcess) {
+      cliProcess.once("exit", () => {
+        if (!isCurrentConnection()) {
+          connection.dispose();
+          return;
+        }
+        if (disconnecting) return;
+        if (this.socket) {
+          disconnectAfterDrain();
+          return;
+        }
+        this.connectionClosed = true;
+        if (messageWriter) messageWriter.suppressWriteErrors = true;
+        exitFallback = setTimeout(disconnectAfterDrain, RUNTIME_SHUTDOWN_TIMEOUT_MS);
+        exitFallback.unref();
+      });
+    }
     this.connection.onError(() => {
-      if (this.connection === connection) {
+      if (connectionEpoch === this.connectionEpoch && this.connection === connection) {
         this.state = "disconnected";
       }
     });

package/dist/ffiRuntimeHost.d.ts

@@ -33,6 +33,7 @@ export declare class FfiRuntimeHost {
      * bytes are copied out before returning.
      */
     private feedInbound;
+    private shutdownHost;
     private unregisterCallback;
     private scheduleCleanupRetry;
     private tryFinalizeCleanup;

package/dist/ffiRuntimeHost.js

@@ -175,7 +175,7 @@ class FfiRuntimeHost {
       );
       if (!this.connectionId) {
         this.unregisterCallback();
-        this.lib.hostShutdown(this.serverId);
+        await this.shutdownHost();
         this.serverId = 0;
         throw new Error("copilot_runtime_connection_open failed.");
       }
@@ -184,7 +184,7 @@ class FfiRuntimeHost {
     } finally {
       this.starting = false;
       if (this.disposed) {
-        void this.tryFinalizeCleanup();
+        await this.tryFinalizeCleanup();
       }
     }
   }
@@ -223,6 +223,17 @@ class FfiRuntimeHost {
       );
     }
   }
+  shutdownHost() {
+    return new Promise((resolvePromise, rejectPromise) => {
+      this.lib.hostShutdown.async(this.serverId, (error, result) => {
+        if (error) {
+          rejectPromise(error);
+        } else {
+          resolvePromise(result);
+        }
+      });
+    });
+  }
   unregisterCallback() {
     if (this.outboundCallback === void 0) {
       return true;
@@ -295,7 +306,7 @@ class FfiRuntimeHost {
       }
       if (this.serverId) {
         try {
-          if (!this.lib.hostShutdown(this.serverId)) {
+          if (!await this.shutdownHost()) {
             console.error(
               `In-process FFI host shutdown did not recognize server ${this.serverId}.`
             );