@github/copilot-sdk 1.0.13-preview.4 → 1.0.13

package/dist/cjs/runtimeArtifacts.js

@@ -18,32 +18,50 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var runtimeArtifacts_exports = {};
 __export(runtimeArtifacts_exports, {
+  RUNTIME_PLATFORMS: () => RUNTIME_PLATFORMS,
   defaultRuntimeCacheRoot: () => defaultRuntimeCacheRoot,
-  materializeRuntimeBundle: () => materializeRuntimeBundle
+  ensureRuntimeBundle: () => ensureRuntimeBundle,
+  getRuntimePackageName: () => getRuntimePackageName,
+  getRuntimePlatform: () => getRuntimePlatform,
+  getRuntimeReleaseAssetName: () => getRuntimeReleaseAssetName,
+  materializeRuntimeBundle: () => materializeRuntimeBundle,
+  resolvePackageRoot: () => resolvePackageRoot,
+  validateFile: () => validateFile
 });
 module.exports = __toCommonJS(runtimeArtifacts_exports);
-var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
+var import_node_crypto = require("node:crypto");
+var import_node_module = require("node:module");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
+var import_cliVersion = require("./cliVersion.js");
+const import_meta = {};
+const require2 = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const RUNTIME_PLATFORMS = [
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+  "linuxmusl-arm64",
+  "linuxmusl-x64",
+  "win32-arm64",
+  "win32-x64"
+];
 const EXCLUDED_TOP_LEVEL = /* @__PURE__ */ new Set([
   "app.js",
   "assets",
   "changelog.json",
   "copilot",
   "copilot.exe",
-  "copilot-sdk",
   "foundry-local-sdk",
   "index.js",
   "LICENSE.md",
   "napi-oop-runtime",
   "npm-loader.js",
   "package.json",
-  "preloads",
   "pvrecorder",
   "queries",
   "README.md",
-  "sdk",
   "sea-loader.js",
   "webview"
 ]);
@@ -82,14 +100,12 @@ function collectRuntimeAssets(sources) {
         continue;
       }
       const parts = sourceRelative.split(import_node_path.sep);
-      let relativePath = sourceRelative;
       if (parts[0] === "prebuilds") {
         if (parts[1] !== sources.platform || parts.length < 3) {
           continue;
         }
-        relativePath = parts.slice(2).join(import_node_path.sep);
       }
-      assets.push({ source, relativePath });
+      assets.push({ source, relativePath: sourceRelative });
     }
   };
   visit(sources.packageRoot);
@@ -117,15 +133,20 @@ function defaultRuntimeCacheRoot(platform = process.platform, home = (0, import_
   const cacheDirectory = platform === "win32" ? environment.LOCALAPPDATA ?? (0, import_node_path.join)(home, "AppData", "Local") : platform === "darwin" ? (0, import_node_path.join)(home, "Library", "Caches") : environment.XDG_CACHE_HOME ?? (0, import_node_path.join)(home, ".cache");
   return (0, import_node_path.join)(cacheDirectory, "github-copilot-sdk", "runtime");
 }
-function materializeRuntimeBundle(sources, cacheRoot = defaultRuntimeCacheRoot()) {
+function materializeRuntimeBundle(sources, cacheRoot = defaultRuntimeCacheRoot(), cacheKey = `${sources.platform}-${sourceFingerprint(collectRuntimeAssets(sources))}`) {
   const assets = collectRuntimeAssets(sources);
-  const wrapperName = process.platform === "win32" ? "copilot-runtime.exe" : "copilot-runtime";
-  const sourceWrapper = assets.find((asset) => asset.relativePath === wrapperName)?.source;
-  const sourceRuntimeNode = assets.find((asset) => asset.relativePath === "runtime.node")?.source;
+  const wrapperName = sources.platform.startsWith("win32") ? "copilot-runtime.exe" : "copilot-runtime";
+  const prebuildDir = (0, import_node_path.join)("prebuilds", sources.platform);
+  const wrapperRelative = (0, import_node_path.join)(prebuildDir, wrapperName);
+  const runtimeNodeRelative = (0, import_node_path.join)(prebuildDir, "runtime.node");
+  const sourceWrapper = assets.find((asset) => asset.relativePath === wrapperRelative)?.source;
+  const sourceRuntimeNode = assets.find(
+    (asset) => asset.relativePath === runtimeNodeRelative
+  )?.source;
   validateRuntimeBundle(sourceWrapper ?? "", sourceRuntimeNode ?? "");
-  const installDir = (0, import_node_path.join)(cacheRoot, `${sources.platform}-${sourceFingerprint(assets)}`);
-  const installedWrapper = (0, import_node_path.join)(installDir, wrapperName);
-  const installedRuntimeNode = (0, import_node_path.join)(installDir, "runtime.node");
+  const installDir = (0, import_node_path.join)(cacheRoot, cacheKey);
+  const installedWrapper = (0, import_node_path.join)(installDir, wrapperRelative);
+  const installedRuntimeNode = (0, import_node_path.join)(installDir, runtimeNodeRelative);
   if ((0, import_node_fs.existsSync)(installDir)) {
     validateRuntimeBundle(installedWrapper, installedRuntimeNode);
     makeExecutable(installedWrapper);
@@ -139,7 +160,7 @@ function materializeRuntimeBundle(sources, cacheRoot = defaultRuntimeCacheRoot()
       (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(destination), { recursive: true });
       (0, import_node_fs.copyFileSync)(asset.source, destination);
     }
-    const stagedWrapper = (0, import_node_path.join)(stagingDir, wrapperName);
+    const stagedWrapper = (0, import_node_path.join)(stagingDir, wrapperRelative);
     makeExecutable(stagedWrapper);
     (0, import_node_fs.renameSync)(stagingDir, installDir);
   } catch (error) {
@@ -152,8 +173,82 @@ function materializeRuntimeBundle(sources, cacheRoot = defaultRuntimeCacheRoot()
   }
   return installedWrapper;
 }
+function isMusl() {
+  if (process.platform !== "linux") {
+    return false;
+  }
+  const report = process.report?.getReport();
+  return report?.header?.glibcVersionRuntime === void 0;
+}
+function getRuntimePlatform(platform = process.platform, arch = process.arch, musl = isMusl()) {
+  if (arch !== "x64" && arch !== "arm64") {
+    throw new Error(`Unsupported Copilot CLI architecture: ${arch}.`);
+  }
+  if (platform === "linux") {
+    return `${musl ? "linuxmusl" : "linux"}-${arch}`;
+  }
+  if (platform === "darwin" || platform === "win32") {
+    return `${platform}-${arch}`;
+  }
+  throw new Error(`Unsupported Copilot CLI platform: ${platform}-${arch}.`);
+}
+function getRuntimeReleaseAssetName(version, platform) {
+  return `github-copilot-${version}-${platform}.tgz`;
+}
+function getRuntimePackageName(platform) {
+  return `@github/copilot-sdk-${platform}`;
+}
+function resolvePackageRoot(packageName, searchPaths = require2.resolve.paths(packageName) ?? []) {
+  return searchPaths.map((base) => (0, import_node_path.join)(base, ...packageName.split("/"))).find((candidate) => (0, import_node_fs.existsSync)((0, import_node_path.join)(candidate, "package.json")));
+}
+async function ensureRuntimeBundle(version, options = {}) {
+  const platform = options.platform ?? getRuntimePlatform();
+  if (import_cliVersion.COPILOT_CLI_USE_NPM_PACKAGE) {
+    const packageName2 = `@github/copilot-${platform}`;
+    const packageRoot2 = resolvePackageRoot(packageName2, options.packageSearchPaths);
+    if (!packageRoot2) {
+      throw new Error(`Could not resolve ${packageName2} for Copilot CLI ${version}.`);
+    }
+    validateFile(
+      (0, import_node_path.join)(packageRoot2, "prebuilds", platform, "runtime.node"),
+      "Copilot runtime.node"
+    );
+    return materializeRuntimeBundle(
+      { packageRoot: packageRoot2, platform },
+      options.cacheRoot,
+      `${version}-${platform}`
+    );
+  }
+  const packageName = getRuntimePackageName(platform);
+  const packageRoot = resolvePackageRoot(packageName, options.packageSearchPaths);
+  if (!packageRoot) {
+    throw new Error(
+      `Could not resolve ${packageName}. Reinstall @github/copilot-sdk so its platform package is installed.`
+    );
+  }
+  const wrapperName = platform.startsWith("win32") ? "copilot-runtime.exe" : "copilot-runtime";
+  const prebuildDir = (0, import_node_path.join)(packageRoot, "prebuilds", platform);
+  const wrapper = (0, import_node_path.join)(prebuildDir, wrapperName);
+  try {
+    validateRuntimeBundle(wrapper, (0, import_node_path.join)(prebuildDir, "runtime.node"));
+  } catch (error) {
+    throw new Error(
+      `${packageName} is missing required Copilot CLI runtime files. Reinstall @github/copilot-sdk.`,
+      { cause: error }
+    );
+  }
+  makeExecutable(wrapper);
+  return wrapper;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RUNTIME_PLATFORMS,
   defaultRuntimeCacheRoot,
-  materializeRuntimeBundle
+  ensureRuntimeBundle,
+  getRuntimePackageName,
+  getRuntimePlatform,
+  getRuntimeReleaseAssetName,
+  materializeRuntimeBundle,
+  resolvePackageRoot,
+  validateFile
 });

package/dist/cjs/session.js

@@ -249,6 +249,7 @@ class CopilotSession {
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
+  pendingExternalTools = /* @__PURE__ */ new Map();
   canvases = /* @__PURE__ */ new Map();
   bearerTokenProviders = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
@@ -268,6 +269,7 @@ class CopilotSession {
   _capabilities = {};
   openCanvasInstances = [];
   disconnected = false;
+  disconnecting = false;
   onDisconnected;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
   clientSessionApis = {};
@@ -525,6 +527,10 @@ class CopilotSession {
       return;
     }
     this.disconnected = true;
+    for (const controller of this.pendingExternalTools.values()) {
+      controller.abort();
+    }
+    this.pendingExternalTools.clear();
     this._runOnDisconnected();
     this.eventHandlers.clear();
     this.typedEventHandlers.clear();
@@ -628,6 +634,15 @@ class CopilotSession {
           tracestate
         );
       }
+    } else if (event.type === "external_tool.completed") {
+      const { requestId } = event.data;
+      if (requestId) {
+        const controller = this.pendingExternalTools.get(requestId);
+        if (controller) {
+          this.pendingExternalTools.delete(requestId);
+          controller.abort();
+        }
+      }
     } else if (event.type === "permission.requested") {
       const { requestId, permissionRequest, resolvedByHook } = event.data;
       if (resolvedByHook) {
@@ -708,16 +723,35 @@ class CopilotSession {
    * @internal
    */
   async _executeToolAndRespond(requestId, toolName, toolCallId, args, handler, traceparent, tracestate) {
+    const controller = new AbortController();
+    if (this.disconnected || this.pendingExternalTools.has(requestId)) {
+      return;
+    }
+    this.pendingExternalTools.set(requestId, controller);
     try {
       let availableTools;
       if (toolName === TOOL_SEARCH_TOOL_NAME) {
+        if (controller.signal.aborted) {
+          return;
+        }
+        const aborted = new Promise((resolve) => {
+          controller.signal.addEventListener("abort", () => resolve(void 0), {
+            once: true
+          });
+        });
         try {
-          const metadata = await this.rpc.tools.getCurrentMetadata();
-          availableTools = metadata.tools ?? void 0;
+          const metadata = await Promise.race([
+            this.rpc.tools.getCurrentMetadata(),
+            aborted
+          ]);
+          availableTools = metadata?.tools ?? void 0;
         } catch {
           availableTools = void 0;
         }
       }
+      if (controller.signal.aborted) {
+        return;
+      }
       const rawResult = await handler(args, {
         sessionId: this.sessionId,
         toolCallId,
@@ -725,7 +759,8 @@ class CopilotSession {
         arguments: args,
         availableTools,
         traceparent,
-        tracestate
+        tracestate,
+        signal: controller.signal
       });
       let result;
       if (rawResult == null) {
@@ -737,12 +772,12 @@ class CopilotSession {
       } else {
         result = JSON.stringify(rawResult);
       }
-      if (this.disconnected) {
+      if (!this._claimExternalTool(requestId, controller)) {
         return;
       }
       await this.rpc.tools.handlePendingToolCall({ requestId, result });
     } catch (error) {
-      if (this.disconnected) {
+      if (!this._claimExternalTool(requestId, controller)) {
         return;
       }
       const message = error instanceof Error ? error.message : String(error);
@@ -753,7 +788,19 @@ class CopilotSession {
           throw rpcError;
         }
       }
+    } finally {
+      if (this.pendingExternalTools.get(requestId) === controller) {
+        this.pendingExternalTools.delete(requestId);
+      }
+      controller.abort();
+    }
+  }
+  _claimExternalTool(requestId, controller) {
+    if (this.disconnected || this.pendingExternalTools.get(requestId) !== controller) {
+      return false;
     }
+    this.pendingExternalTools.delete(requestId);
+    return true;
   }
   /**
    * Executes a permission handler and sends the result back via RPC.
@@ -1507,13 +1554,27 @@ class CopilotSession {
    * ```
    */
   async disconnect() {
-    if (this.disconnected) {
+    if (this.disconnected || this.disconnecting) {
       return;
     }
-    await this.connection.sendRequest("session.destroy", {
-      sessionId: this.sessionId
-    });
-    this._markDisconnected();
+    this.disconnecting = true;
+    try {
+      let response = { success: false };
+      for (let attempt = 0; attempt < 2 && !response.success; attempt++) {
+        response = await this.connection.sendRequest("session.detach", {
+          sessionId: this.sessionId
+        });
+      }
+      if (!response.success) {
+        throw new Error(
+          `Failed to disconnect session ${this.sessionId}: ${response.error || "Unknown error"}`
+        );
+      }
+      this._markDisconnected();
+    } catch (error) {
+      this.disconnecting = false;
+      throw error;
+    }
   }
   /** Enables `await using session = ...` syntax for automatic cleanup. */
   async [Symbol.asyncDispose]() {
@@ -1555,11 +1616,48 @@ class CopilotSession {
    * ```typescript
    * await session.setModel("gpt-5.4");
    * await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
+   *
+   * // Select the Auto model and its routing preference in one call.
+   * await session.setModel("auto", { autoTier: "intelligence" });
    * ```
    */
   async setModel(model, options) {
     await this.rpc.model.switchTo({ modelId: model, ...options });
   }
+  /**
+   * Change the Auto routing preference without changing the selected model.
+   *
+   * The runtime does not apply the preference immediately. It records the
+   * request and commits it only when a later user turn using the `auto` model
+   * successfully obtains a usable model from the provider. A `pending` status
+   * therefore confirms that the request was accepted, not that it took effect.
+   *
+   * Watch for the outcome through the `session.model_change` event on success,
+   * or the ephemeral `session.auto_tier_switch_failed` event on failure. You
+   * can also read the current committed and in-flight state at any time with
+   * `session.rpc.model.getCurrent()`.
+   *
+   * Only the most recent request survives: issuing a new request replaces any
+   * earlier one that has not yet been claimed by a turn.
+   *
+   * @param autoTier - Routing preference to activate, or `null` to return to
+   *   the provider's default Auto routing
+   * @returns The runtime's immediate acknowledgement and Auto preference snapshot
+   *
+   * @experimental Part of an experimental Auto routing surface and may change
+   * or be removed in a future release.
+   *
+   * @example
+   * ```typescript
+   * const result = await session.setAutoTier("intelligence");
+   * if (result.status === "pending") {
+   *     // Takes effect on a later turn that uses the `auto` model.
+   * }
+   * ```
+   */
+  async setAutoTier(autoTier) {
+    return await this.rpc.model.switchAutoTier({ autoTier });
+  }
   /**
    * Log a message to the session timeline.
    * The message appears in the session event stream and is visible to SDK consumers

package/dist/cliVersion.d.ts

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

package/dist/cliVersion.js

@@ -0,0 +1,6 @@
+const COPILOT_CLI_VERSION = "1.0.83";
+const COPILOT_CLI_USE_NPM_PACKAGE = false;
+export {
+  COPILOT_CLI_USE_NPM_PACKAGE,
+  COPILOT_CLI_VERSION
+};

package/dist/client.d.ts

@@ -7,6 +7,7 @@ export declare class CopilotClient {
     private ffiHost;
     private connection;
     private messageWriter;
+    private connectionClosed;
     private socket;
     private runtimePort;
     private actualHost;
@@ -92,7 +93,7 @@ export declare class CopilotClient {
     private connectionExtraArgs;
     /**
      * Parse CLI URL into host and port
-     * Supports formats: "host:port", "http://host:port", "https://host:port", or just "port"
+     * Supports formats: "host:port", "[ipv6]:port", "http://host:port", "https://host:port", or just "port"
      */
     private parseCliUrl;
     private validateSessionFsConfig;