@github/copilot-sdk-linuxmusl-x64 1.0.14-preview.1 → 1.0.14

package/copilot-sdk/index.js

@@ -3318,7 +3318,7 @@ var require_empty_npm_package = __commonJS({
   }
 });
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/ffiRuntimeHost.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/ffiRuntimeHost.js
 var ffiRuntimeHost_exports = {};
 __export(ffiRuntimeHost_exports, {
   FfiRuntimeHost: () => FfiRuntimeHost
@@ -3391,12 +3391,13 @@ function buildEnvJson(environment) {
   }
   return Buffer.from(JSON.stringify(obj), "utf8");
 }
-var import_koffi, SYMBOL_PREFIX, KEEP_ALIVE_INTERVAL_MS, loadedLibraryPath, loadedLibrary, FfiRuntimeHost;
+var import_koffi, SYMBOL_PREFIX, KEEP_ALIVE_INTERVAL_MS, CLEANUP_RETRY_INTERVAL_MS, loadedLibraryPath, loadedLibrary, FfiRuntimeHost;
 var init_ffiRuntimeHost = __esm({
-  "node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/ffiRuntimeHost.js"() {
+  "node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/ffiRuntimeHost.js"() {
     import_koffi = __toESM(require_empty_npm_package(), 1);
     SYMBOL_PREFIX = "copilot_runtime_";
     KEEP_ALIVE_INTERVAL_MS = 1 << 30;
+    CLEANUP_RETRY_INTERVAL_MS = 100;
     FfiRuntimeHost = class _FfiRuntimeHost {
       constructor(libraryPath, cliEntrypoint, environment, args) {
         this.libraryPath = libraryPath;
@@ -3422,12 +3423,16 @@ var init_ffiRuntimeHost = __esm({
       cliEntrypoint;
       environment;
       args;
+      static quarantinedHosts = /* @__PURE__ */ new Set();
       lib;
       serverId = 0;
       connectionId = 0;
       disposed = false;
+      starting = false;
       outboundCallback;
       keepAliveTimer;
+      cleanupRetryTimer;
+      cleanupInProgress = false;
       /** The stream JSON-RPC reads server→client frames from. */
       receiveStream;
       /** The stream JSON-RPC writes client→server frames to. */
@@ -3449,49 +3454,65 @@ var init_ffiRuntimeHost = __esm({
       }
       /** Starts the in-process Rust runtime and opens the FFI JSON-RPC connection. */
       async start() {
+        if (this.disposed) {
+          throw new Error("The in-process runtime host is disposed.");
+        }
+        this.starting = true;
         const argvJson = buildArgvJson(this.cliEntrypoint, this.args);
         const envJson = buildEnvJson(this.environment);
-        this.serverId = await new Promise((resolvePromise, rejectPromise) => {
-          this.lib.hostStart.async(
-            argvJson,
-            argvJson.length,
-            envJson,
-            envJson ? envJson.length : 0,
-            (error, result) => {
-              if (error) {
-                rejectPromise(error);
-              } else {
-                resolvePromise(result);
+        try {
+          this.serverId = await new Promise((resolvePromise, rejectPromise) => {
+            this.lib.hostStart.async(
+              argvJson,
+              argvJson.length,
+              envJson,
+              envJson ? envJson.length : 0,
+              (error, result) => {
+                if (error) {
+                  rejectPromise(error);
+                } else {
+                  resolvePromise(result);
+                }
               }
-            }
+            );
+          });
+          if (!this.serverId) {
+            throw new Error(
+              `copilot_runtime_host_start failed (library '${this.libraryPath}').`
+            );
+          }
+          if (this.disposed) {
+            throw new Error("The in-process runtime host was disposed during startup.");
+          }
+          this.outboundCallback = import_koffi.default.register(
+            (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),
+            this.lib.outboundCallbackType
           );
-        });
-        if (!this.serverId) {
-          throw new Error(`copilot_runtime_host_start failed (library '${this.libraryPath}').`);
-        }
-        this.outboundCallback = import_koffi.default.register(
-          (_userData, bytesPtr, bytesLen) => this.feedInbound(bytesPtr, bytesLen),
-          this.lib.outboundCallbackType
-        );
-        this.connectionId = this.lib.connectionOpen(
-          this.serverId,
-          this.outboundCallback,
-          null,
-          null,
-          0,
-          null,
-          0,
-          null,
-          0
-        );
-        if (!this.connectionId) {
-          this.unregisterCallback();
-          this.lib.hostShutdown(this.serverId);
-          this.serverId = 0;
-          throw new Error("copilot_runtime_connection_open failed.");
+          this.connectionId = this.lib.connectionOpen(
+            this.serverId,
+            this.outboundCallback,
+            null,
+            null,
+            0,
+            null,
+            0,
+            null,
+            0
+          );
+          if (!this.connectionId) {
+            this.unregisterCallback();
+            this.lib.hostShutdown(this.serverId);
+            this.serverId = 0;
+            throw new Error("copilot_runtime_connection_open failed.");
+          }
+          this.keepAliveTimer = setInterval(() => {
+          }, KEEP_ALIVE_INTERVAL_MS);
+        } finally {
+          this.starting = false;
+          if (this.disposed) {
+            void this.tryFinalizeCleanup();
+          }
         }
-        this.keepAliveTimer = setInterval(() => {
-        }, KEEP_ALIVE_INTERVAL_MS);
       }
       writeFrame(frame) {
         if (this.disposed || !this.connectionId) {
@@ -3530,57 +3551,119 @@ var init_ffiRuntimeHost = __esm({
       }
       unregisterCallback() {
         if (this.outboundCallback === void 0) {
-          return;
+          return true;
         }
         const callback = this.outboundCallback;
-        this.outboundCallback = void 0;
         try {
           import_koffi.default.unregister(callback);
-        } catch {
+          this.outboundCallback = void 0;
+          return true;
+        } catch (error) {
+          console.error(
+            `Failed to unregister in-process FFI callback: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+          );
+          _FfiRuntimeHost.quarantinedHosts.add(this);
+          return false;
         }
       }
-      /** Closes the FFI connection, shuts down the native host, and releases resources. */
-      dispose() {
-        if (this.disposed) {
+      scheduleCleanupRetry() {
+        if (this.cleanupRetryTimer !== void 0) {
           return;
         }
-        this.disposed = true;
-        if (this.keepAliveTimer !== void 0) {
-          clearInterval(this.keepAliveTimer);
-          this.keepAliveTimer = void 0;
+        this.cleanupRetryTimer = setTimeout(() => {
+          this.cleanupRetryTimer = void 0;
+          void this.tryFinalizeCleanup();
+        }, CLEANUP_RETRY_INTERVAL_MS);
+      }
+      async tryFinalizeCleanup() {
+        if (this.cleanupInProgress) {
+          this.scheduleCleanupRetry();
+          return;
         }
+        this.cleanupInProgress = true;
         try {
           if (this.connectionId) {
-            this.lib.connectionClose(this.connectionId);
+            let closed = false;
+            try {
+              closed = await new Promise((resolvePromise, rejectPromise) => {
+                this.lib.connectionClose.async(
+                  this.connectionId,
+                  (error, result) => {
+                    if (error) {
+                      rejectPromise(error);
+                    } else {
+                      resolvePromise(result);
+                    }
+                  }
+                );
+              });
+            } catch (error) {
+              console.error(
+                `Failed to close in-process FFI connection: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+              );
+              _FfiRuntimeHost.quarantinedHosts.add(this);
+              if (this.keepAliveTimer !== void 0) {
+                clearInterval(this.keepAliveTimer);
+                this.keepAliveTimer = void 0;
+              }
+              return;
+            }
+            if (!closed) {
+              this.scheduleCleanupRetry();
+              return;
+            }
             this.connectionId = 0;
           }
-        } catch {
-        }
-        try {
+          const callbackUnregistered = this.unregisterCallback();
+          if (this.keepAliveTimer !== void 0) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = void 0;
+          }
           if (this.serverId) {
-            this.lib.hostShutdown(this.serverId);
+            try {
+              if (!this.lib.hostShutdown(this.serverId)) {
+                console.error(
+                  `In-process FFI host shutdown did not recognize server ${this.serverId}.`
+                );
+              }
+            } catch (error) {
+              console.error(
+                `Failed to shut down in-process FFI host: ${error instanceof Error ? error.stack ?? error.message : String(error)}`
+              );
+            }
             this.serverId = 0;
           }
-        } catch {
+          if (callbackUnregistered) {
+            _FfiRuntimeHost.quarantinedHosts.delete(this);
+          }
+        } finally {
+          this.cleanupInProgress = false;
+        }
+      }
+      /** Awaits the initial cleanup attempt; a non-quiescent close is retried in the background. */
+      async dispose() {
+        if (this.disposed) {
+          return;
         }
+        this.disposed = true;
         this.receiveStream.end();
-        this.unregisterCallback();
+        if (!this.starting) {
+          await this.tryFinalizeCleanup();
+        }
       }
     };
   }
 });
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/client.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/client.js
 var import_node2 = __toESM(require_node(), 1);
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { createRequire } from "node:module";
-import { Socket } from "node:net";
+import { isIPv6, Socket } from "node:net";
 import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve2 } from "node:path";
-import { fileURLToPath } from "node:url";
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/generated/rpc.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/generated/rpc.js
 function createServerRpc(connection) {
   return {
     /**
@@ -3594,6 +3677,17 @@ function createServerRpc(connection) {
      */
     ping: async (params) => connection.sendRequest("ping", params),
     /** @experimental */
+    hooks: {
+      /**
+       * Discovers hook actions enabled under server-side discovery settings from user, repository, plugin, and managed-policy sources.
+       *
+       * @param params Optional project paths and host-exclusion behavior for server-scoped hook discovery.
+       *
+       * @returns Server-discovered hook actions and partial-load diagnostics from user, repository, plugin, and managed-policy sources. Concrete sessions may include additional session-specific hook sources.
+       */
+      discover: async (params) => connection.sendRequest("hooks.discover", params)
+    },
+    /** @experimental */
     models: {
       /**
        * Lists Copilot models available to the authenticated user.
@@ -3810,13 +3904,13 @@ function createServerRpc(connection) {
       /**
        * Enables installed plugins for new sessions.
        *
-       * @param params Plugin names (or specs) to enable.
+       * @param params Plugin names (or specs) to enable, plus the optional working directory the repository-controlled guard is evaluated against.
        */
       enable: async (params) => connection.sendRequest("plugins.enable", params),
       /**
        * Disables installed plugins for new sessions.
        *
-       * @param params Plugin names (or specs) to disable.
+       * @param params Plugin names (or specs) to disable, plus the optional working directory the repository-controlled guard is evaluated against.
        */
       disable: async (params) => connection.sendRequest("plugins.disable", params),
       /** @experimental */
@@ -3982,7 +4076,11 @@ function createServerRpc(connection) {
        *
        * @returns Validated device-managed settings discovered before a session exists.
        */
-      read: async () => connection.sendRequest("managedSettings.read", {})
+      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.
+       */
+      clearCache: async () => connection.sendRequest("managedSettings.clearCache", {})
     },
     /** @experimental */
     runtime: {
@@ -4061,6 +4159,22 @@ function createServerRpc(connection) {
        * @returns Sessions matching the filter, ordered most-recently-modified first.
        */
       list: async (params) => connection.sendRequest("sessions.list", params),
+      /**
+       * Reads client-owned metadata for multiple persisted local sessions without opening them. Results preserve request order and report missing, corrupt, unsupported, or temporarily unavailable sessions independently.
+       *
+       * @param params Bounded batch request for client-owned metadata from persisted local sessions.
+       *
+       * @returns Ordered client metadata outcomes for the requested local sessions.
+       */
+      getClientMetadata: async (params) => connection.sendRequest("sessions.getClientMetadata", params),
+      /**
+       * Reads a page of durable events directly from a local session's persisted journal without creating, resuming, or activating the session. The first read pins the currently opened journal generation and its byte-length boundary; opaque cursor continuations remain on that generation across runtime-owned compaction, truncation, and rewrite operations, which replace the live path atomically, and events appended after the boundary are excluded. For cold hydration, await the first successful page before activation and establish lossless live-event buffering before resume; merge subsequent live events by ID, preserving persisted order and letting live payloads win. Continuations are process-local, single-use capabilities bound to the originating session and storage context and must be paged sequentially; concurrent or repeated use of the same cursor expires that duplicate read rather than reading the generation twice. A complete snapshot has cursorStatus 'ok' and hasMore false. Snapshots expire after five idle minutes, with at most eight retained per process and idle-only eviction under pressure; completion and cancelled-worker exit release their handles. No transcript copy is created, but retained handles may keep replaced files' disk blocks alive until release. Pages have a soft 1 MiB serialized event-array budget including resolved binary assets; one oversized event is returned alone to guarantee progress. Working memory also includes a record/lookahead and asset resolution; resolving the first binary reference may scan the full pinned generation to build a bounded offset index. If the snapshot expires, is evicted, is cancelled before a continuation is established, or becomes unreadable after an observable unsupported in-place shortening, the continuation returns cursorStatus 'expired' with an empty terminal page and never falls back to a different generation. A missing or initially unreadable journal is an RPC error. Persisted history excludes ephemeral events and may omit payloads that are reconstructed only for an active session; use the active session event stream for post-resume live events.
+       *
+       * @param params Pagination options for reading an inactive or active local session's persisted event journal.
+       *
+       * @returns Batch of session events returned by a read, with cursor and continuation metadata.
+       */
+      readPersistedEvents: async (params) => connection.sendRequest("sessions.readPersistedEvents", params),
       /**
        * Finds the local session bound to a GitHub task ID, if any.
        *
@@ -4335,7 +4449,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Managed sandbox enforcement state for a session.
        */
-      getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId })
+      getEnforcementStatus: async () => connection.sendRequest("session.sandbox.getEnforcementStatus", { sessionId }),
+      /**
+       * Disables sandboxing for the remainder of the current session and approves the referenced pending sandbox-bypass permission request. The request is rejected unless the exact request is still pending and the effective sandbox policy permits bypass.
+       *
+       * @param params Request to disable sandboxing for the current session while resolving an active sandbox-bypass permission prompt.
+       *
+       * @returns Result of attempting to disable sandboxing for the current session.
+       */
+      disableForSession: async (params) => connection.sendRequest("session.sandbox.disableForSession", { sessionId, ...params })
     },
     /**
      * Aborts the current agent turn.
@@ -4499,6 +4621,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Complete current or terminal factory run envelope.
        */
       cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
+      /**
+       * Pauses a running factory and returns its settled run envelope.
+       *
+       * @param params Parameters for pausing a running factory.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      pause: async (params) => connection.sendRequest("session.factory.pause", { sessionId, ...params }),
       /**
        * Records a batch of ordered factory progress lines.
        *
@@ -4538,9 +4668,9 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     model: {
       /**
-       * Gets the currently selected model for the session.
+       * Gets the session's authoritative model snapshot, including the committed Auto preference and any newer unclaimed Auto preference waiting for a future user turn.
        *
-       * @returns The currently selected model, reasoning effort, and context tier for the session. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.
+       * @returns The session's authoritative model snapshot. Auto preference fields are configuration for the virtual `auto` model and do not change the selected model identifier. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.
        */
       getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
       /**
@@ -4551,6 +4681,22 @@ function createSessionRpc(connection, sessionId) {
        * @returns The model identifier active on the session after the switch.
        */
       switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params }),
+      /**
+       * Requests an Auto preference change without changing the session's selected model. The latest unclaimed request wins; the runtime commits it only after a later prompt using the `auto` model mints a usable model and token pair. A `pending` response confirms that the request was accepted, not that it committed. Observe eventual success through `session.model_change`, failure through the ephemeral `session.auto_tier_switch_failed` event, or current unclaimed state through `session.model.getCurrent`.
+       *
+       * @param params An Auto preference request for the session. This updates Auto configuration only; it does not change the selected model to `auto`.
+       *
+       * @returns Immediate acknowledgement and Auto preference snapshot after a switch request. This result never implies that a pending preference committed.
+       */
+      switchAutoTier: async (params) => connection.sendRequest("session.model.switchAutoTier", { sessionId, ...params }),
+      /**
+       * Replaces or clears the host-supplied model allowlist for a running session.
+       *
+       * @param params Host-supplied exact model selection IDs to allow for this running session. CAPI IDs are intersected with repository `.github/allowed_models.txt` policy; provider-qualified IDs remain exempt from repository-only policy but are restricted by this host list. Omit or pass null to clear the host restriction; an explicit empty or disjoint list is rejected. Validation and pre-selection fallback failures preserve the previous restriction. Failures after a fallback selection commits retain the new restriction and selected model; callers should inspect current session state after such an error.
+       *
+       * @returns The applied host allowlist and effective session model policy after intersection.
+       */
+      setAllowedModels: async (params) => connection.sendRequest("session.model.setAllowedModels", { sessionId, ...params }),
       /**
        * Updates the session's reasoning effort without changing the selected model.
        *
@@ -4757,6 +4903,15 @@ function createSessionRpc(connection, sessionId) {
       diff: async (params) => connection.sendRequest("session.workspaces.diff", { sessionId, ...params })
     },
     /** @experimental */
+    autopilotObjective: {
+      /**
+       * Reads the current canonical autopilot objective state for this session.
+       *
+       * @returns Canonical runtime state for the session's current autopilot objective.
+       */
+      getState: async () => connection.sendRequest("session.autopilotObjective.getState", { sessionId })
+    },
+    /** @experimental */
     completions: {
       /**
        * Gets the characters that should trigger host-driven completions for the session. Empty disables host-driven completions (e.g. local sessions, or a relay host that does not advertise them).
@@ -4787,7 +4942,7 @@ function createSessionRpc(connection, sessionId) {
       /**
        * Starts fleet mode by submitting the fleet orchestration prompt to the session.
        *
-       * @param params Optional user prompt to combine with the fleet orchestration instructions.
+       * @param params Parameters for starting fleet orchestration: an optional user prompt combined with the fleet instructions, plus the send options forwarded to the resulting turn.
        *
        * @returns Indicates whether fleet mode was successfully activated.
        */
@@ -4850,6 +5005,22 @@ function createSessionRpc(connection, sessionId) {
        * @returns Background tasks currently tracked by the session.
        */
       list: async () => connection.sendRequest("session.tasks.list", { sessionId }),
+      /**
+       * Registers a client-owned task, or reclaims an orphaned task belonging to the same extension principal.
+       *
+       * @param params Registers or reclaims a client-owned task.
+       *
+       * @returns Result of registering or reclaiming a client-owned task.
+       */
+      register: async (params) => connection.sendRequest("session.tasks.register", { sessionId, ...params }),
+      /**
+       * Publishes generic progress or a terminal outcome for a client-owned task.
+       *
+       * @param params Updates a client-owned task.
+       *
+       * @returns Result of publishing a client-owned task update.
+       */
+      update: async (params) => connection.sendRequest("session.tasks.update", { sessionId, ...params }),
       /**
        * Refreshes metadata for any detached background shells the runtime knows about.
        *
@@ -5313,7 +5484,7 @@ function createSessionRpc(connection, sessionId) {
        */
       set: async (params) => connection.sendRequest("session.tools.set", { sessionId, ...params }),
       /**
-       * Updates the current session's live subagent settings after user settings change. The persisted user settings remain the source of truth for future sessions.
+       * Sets the current session's live subagent settings override, which takes precedence over persisted user settings until cleared. Persisted user settings remain the source of truth for future sessions.
        *
        * @param params Subagent settings to apply to the current session
        *
@@ -5663,6 +5834,20 @@ function createSessionRpc(connection, sessionId) {
        * @returns Point-in-time snapshot of slow-changing session identifier and state fields
        */
       snapshot: async () => connection.sendRequest("session.metadata.snapshot", { sessionId }),
+      /**
+       * Returns the client-owned string metadata persisted with this local session. The metadata is not included in model context, events, telemetry, snapshots, or remote exports.
+       *
+       * @returns Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.
+       */
+      getClientMetadata: async () => connection.sendRequest("session.metadata.getClientMetadata", { sessionId }),
+      /**
+       * Atomically patches the client-owned string metadata persisted with this local session and returns the committed bag.
+       *
+       * @param params Atomic patch for client-owned session metadata. Operations apply in clear, remove, then set order. The resulting bag must satisfy the ClientMetadata entry and serialized-size limits. Local storage coordinates concurrent runtime processes; custom SessionFs providers must serialize writers that access the same session from multiple processes.
+       *
+       * @returns Client-owned, case-sensitive string metadata persisted with a local session. Clients should namespace keys by owner. Keys must be non-empty and at most 256 UTF-8 bytes; keys under `copilot/` and `github/` are reserved. Values may contain at most 16 KiB of UTF-8 data. A bag may contain at most 128 entries and its serialized sidecar may contain at most 64 KiB. The runtime stores but never interprets these values.
+       */
+      updateClientMetadata: async (params) => connection.sendRequest("session.metadata.updateClientMetadata", { sessionId, ...params }),
       /**
        * Reports whether the local session is currently processing user/agent messages.
        *
@@ -6020,6 +6205,294 @@ function createSessionRpc(connection, sessionId) {
     }
   };
 }
+function createInternalSessionRpc(connection, sessionId) {
+  return {
+    /**
+     * Queues or sends an internal system notification to the session according to its passive policy.
+     *
+     * @param params Internal request for sending a system notification.
+     *
+     * @experimental
+     */
+    sendSystemNotification: async (params) => connection.sendRequest("session.sendSystemNotification", { sessionId, ...params }),
+    /** @experimental */
+    gitHubAuth: {
+      /**
+       * Gets the current authentication information for internal session hosts.
+       *
+       * @returns Current authentication information, or null when no authentication is active.
+       */
+      getCurrentAuthInfo: async () => connection.sendRequest("session.gitHubAuth.getCurrentAuthInfo", { sessionId }),
+      /**
+       * Gets all authentication accounts available to the internal session host.
+       *
+       * @returns Authentication accounts available to the internal session host.
+       */
+      getAllAuthAvailable: async () => connection.sendRequest("session.gitHubAuth.getAllAuthAvailable", { sessionId }),
+      /**
+       * Refreshes Copilot account metadata for the current authentication.
+       *
+       * @returns Current authentication information, or null when no authentication is active.
+       */
+      refreshCopilotUser: async () => connection.sendRequest("session.gitHubAuth.refreshCopilotUser", { sessionId }),
+      /**
+       * Logs in a GitHub user through the internal session host.
+       *
+       * @param params Internal GitHub login parameters.
+       *
+       * @returns Authentication credentials accepted only at native protocol ingress. Runtime outputs use credential-free `AuthIdentity` metadata.
+       */
+      login: async (params) => connection.sendRequest("session.gitHubAuth.login", { sessionId, ...params }),
+      /**
+       * Switches the session to another available authentication.
+       *
+       * @param params Parameters for switching the session's active authentication.
+       */
+      switchToAuth: async (params) => connection.sendRequest("session.gitHubAuth.switchToAuth", { sessionId, ...params }),
+      /**
+       * Logs out the session's current GitHub authentication.
+       *
+       * @returns Whether the current authentication was logged out.
+       */
+      logout: async () => connection.sendRequest("session.gitHubAuth.logout", { sessionId }),
+      /**
+       * Logs out a specific GitHub authentication.
+       *
+       * @param params Parameters identifying a GitHub authentication to log out.
+       *
+       * @returns Whether the requested authentication was logged out.
+       */
+      logoutUser: async (params) => connection.sendRequest("session.gitHubAuth.logoutUser", { sessionId, ...params }),
+      /**
+       * Gets validation errors from the most recent authentication attempt.
+       *
+       * @returns Validation errors from the most recent authentication attempt.
+       */
+      lastAuthErrors: async () => connection.sendRequest("session.gitHubAuth.lastAuthErrors", { sessionId })
+    },
+    /** @experimental */
+    canvas: {
+      /** @experimental */
+      provider: {
+        /**
+         * Registers an internal canvas provider connection and its contributions.
+         *
+         * @param params Internal canvas provider registration parameters.
+         */
+        register: async (params) => connection.sendRequest("session.canvas.provider.register", { sessionId, ...params }),
+        /**
+         * Unregisters an internal canvas provider connection.
+         *
+         * @param params Internal canvas provider unregistration parameters.
+         */
+        unregister: async (params) => connection.sendRequest("session.canvas.provider.unregister", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
+    factory: {
+      /**
+       * Internal tool-originated factory invocation.
+       *
+       * @param params Internal parameters for invoking a registered factory from a tool.
+       *
+       * @returns Complete current or terminal factory run envelope.
+       */
+      runFromTool: async (params) => connection.sendRequest("session.factory.runFromTool", { sessionId, ...params }),
+      /**
+       * Internal tool-originated factory resume.
+       *
+       * @param params Internal parameters for resuming a factory run from a tool.
+       *
+       * @returns Resolved persisted factory identity and resumed run envelope.
+       */
+      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params }),
+      /**
+       * Atomically pauses an owned factory attempt at a durable checkpoint.
+       *
+       * @param params Parameters for an owned durable pause checkpoint.
+       */
+      pauseAtCheckpoint: async (params) => connection.sendRequest("session.factory.pauseAtCheckpoint", { sessionId, ...params })
+    },
+    /** @experimental */
+    model: {
+      /**
+       * Resolves and applies organization-managed and repository model overlays.
+       *
+       * @param params Managed, repository, and CLI model overrides to overlay onto the session at startup.
+       *
+       * @returns The model identifier active on the session after the switch.
+       */
+      applyStartupOverlay: async (params) => connection.sendRequest("session.model.applyStartupOverlay", { sessionId, ...params })
+    },
+    /** @experimental */
+    mcp: {
+      /**
+       * Reloads MCP server connections for the session with an explicit host-provided configuration.
+       *
+       * @param params Opaque MCP reload configuration.
+       *
+       * @returns MCP server startup filtering result.
+       */
+      reloadWithConfig: async (params) => connection.sendRequest("session.mcp.reloadWithConfig", { sessionId, ...params }),
+      /**
+       * Configures the built-in GitHub MCP server for the session's current auth context.
+       *
+       * @param params Credential-free authentication identity used to configure GitHub MCP.
+       *
+       * @returns Result of configuring GitHub MCP.
+       */
+      configureGitHub: async (params) => connection.sendRequest("session.mcp.configureGitHub", { sessionId, ...params }),
+      /**
+       * Registers a pre-connected external MCP client (e.g. IDE) on the session's host. The caller retains lifecycle ownership of the client and transport. Marked internal because the `client` and `transport` arguments are in-process MCP SDK instances that cannot be serialized across the JSON-RPC boundary; once the CLI moves on top of the SDK, external clients will be expressed as transport configs the runtime can construct itself.
+       *
+       * @param params Registration parameters for an external MCP client.
+       */
+      registerExternalClient: async (params) => connection.sendRequest("session.mcp.registerExternalClient", { sessionId, ...params }),
+      /**
+       * Unregisters a previously registered external MCP client by server name. Marked internal as the paired companion of `registerExternalClient`: only in-process callers that registered a client this way can meaningfully unregister it. Disappears alongside `registerExternalClient`: once external clients are described to the runtime as config rather than handed in as instances, lifecycle (including deregistration) is owned entirely by the runtime.
+       *
+       * @param params Server name identifying the external client to remove.
+       */
+      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { sessionId, ...params })
+    },
+    /** @experimental */
+    commands: {
+      /**
+       * Finalizes persistence associated with a client-applied slash-command effect.
+       *
+       * @param params The pending slash-command invocation effect to finalize, plus whether the host applied or cancelled it.
+       *
+       * @returns Whether finalizing the invocation effect succeeded, and the failure reason when it did not.
+       */
+      finalizeInvocationEffect: async (params) => connection.sendRequest("session.commands.finalizeInvocationEffect", { sessionId, ...params })
+    },
+    /** @experimental */
+    settings: {
+      /**
+       * Returns a redacted snapshot of session runtime settings, with secrets and raw feature flags excluded. Internal: the runtime settings shape is a runtime-internal surface and is deliberately kept out of the public SDK, because consumers should not depend on the runtime's internal settings layout. It remains callable in-process and is expected to be reworked as the runtime internals are consolidated.
+       *
+       * @returns Redacted, serializable view of session runtime settings for SDK boundary consumers. Secrets and raw feature flags are intentionally excluded.
+       */
+      snapshot: async () => connection.sendRequest("session.settings.snapshot", { sessionId }),
+      /**
+       * Evaluates a named Rust-owned settings predicate without exposing raw feature flags. Internal: the raw feature-flag names and composition are runtime-internal, so this predicate-evaluation helper is kept out of the public SDK surface and is callable in-process only.
+       *
+       * @param params Named Rust-owned settings predicate to evaluate for this session.
+       *
+       * @returns Result of evaluating a Rust-owned settings predicate.
+       */
+      evaluatePredicate: async (params) => connection.sendRequest("session.settings.evaluatePredicate", { sessionId, ...params })
+    },
+    /** @experimental */
+    queue: {
+      /**
+       * Returns the internal native queue snapshot for in-process session orchestration.
+       *
+       * @returns Internal snapshot of native queue state for local session orchestration.
+       */
+      snapshot: async () => connection.sendRequest("session.queue.snapshot", { sessionId }),
+      /**
+       * Reports whether the local session has native queued work pending.
+       *
+       * @returns Whether the native queue has pending work.
+       */
+      hasPending: async () => connection.sendRequest("session.queue.hasPending", { sessionId }),
+      /**
+       * Begins a native deferred-idle drain when background work has quiesced.
+       *
+       * @param params Inputs for starting a deferred-idle drain.
+       *
+       * @returns Whether a deferred-idle drain should run.
+       */
+      beginDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.beginDeferredIdleDrain", { sessionId, ...params }),
+      /**
+       * Finishes a native deferred-idle drain and reports whether to drain queue work or emit idle.
+       *
+       * @param params Inputs for completing a deferred-idle drain.
+       *
+       * @returns Action selected by the native deferred-idle drain.
+       */
+      finishDeferredIdleDrain: async (params) => connection.sendRequest("session.queue.finishDeferredIdleDrain", { sessionId, ...params }),
+      /**
+       * Marks session.idle as deferred by native background work state.
+       *
+       * @param params Inputs for marking session.idle deferred in native state.
+       */
+      deferSessionIdle: async (params) => connection.sendRequest("session.queue.deferSessionIdle", { sessionId, ...params }),
+      /**
+       * Consumes queued native system notifications matching an internal filter.
+       *
+       * @param params Internal filter for consuming queued system notifications.
+       *
+       * @returns Indicates whether a user-facing pending item was removed.
+       */
+      consumeSystemNotifications: async (params) => connection.sendRequest("session.queue.consumeSystemNotifications", { sessionId, ...params }),
+      /**
+       * Enqueues the internal resume-pending wake item when orphan handling needs a follow-up turn.
+       *
+       * @returns Result of enqueueing the resume-pending wake item.
+       */
+      enqueueResumePending: async () => connection.sendRequest("session.queue.enqueueResumePending", { sessionId }),
+      /**
+       * Drains the native local-session work queue for in-process session orchestration.
+       */
+      process: async () => connection.sendRequest("session.queue.process", { sessionId })
+    },
+    /** @experimental */
+    schedule: {
+      /**
+       * Hydrates the native schedule registry from persisted session events.
+       */
+      hydrate: async () => connection.sendRequest("session.schedule.hydrate", { sessionId }),
+      /**
+       * Reports whether the session has an active self-paced scheduled prompt.
+       *
+       * @returns Whether the session currently has an active self-paced schedule.
+       */
+      hasSelfPaced: async () => connection.sendRequest("session.schedule.hasSelfPaced", { sessionId }),
+      /**
+       * Registers a relative-interval scheduled prompt.
+       *
+       * @param params Register a relative-interval scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      add: async (params) => connection.sendRequest("session.schedule.add", { sessionId, ...params }),
+      /**
+       * Registers a recurring cron scheduled prompt.
+       *
+       * @param params Register a cron scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addCron: async (params) => connection.sendRequest("session.schedule.addCron", { sessionId, ...params }),
+      /**
+       * Registers an absolute-time scheduled prompt.
+       *
+       * @param params Register an absolute-time scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addAt: async (params) => connection.sendRequest("session.schedule.addAt", { sessionId, ...params }),
+      /**
+       * Registers a self-paced scheduled prompt.
+       *
+       * @param params Register a self-paced scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      addSelfPaced: async (params) => connection.sendRequest("session.schedule.addSelfPaced", { sessionId, ...params }),
+      /**
+       * Re-arms an active self-paced scheduled prompt.
+       *
+       * @param params Re-arm a self-paced scheduled prompt.
+       *
+       * @returns Result of registering or re-arming a scheduled prompt.
+       */
+      rearmSelfPaced: async (params) => connection.sendRequest("session.schedule.rearmSelfPaced", { sessionId, ...params })
+    }
+  };
+}
 function registerClientSessionApiHandlers(connection, getHandlers) {
   connection.onRequest("providerToken.getToken", async (params) => {
     const handler = getHandlers(params.sessionId).providerToken;
@@ -6036,6 +6509,11 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
     return handler.abort(params);
   });
+  connection.onRequest("tasks.cancel", async (params) => {
+    const handler = getHandlers(params.sessionId).tasks;
+    if (!handler) throw new Error(`No tasks handler registered for session: ${params.sessionId}`);
+    return handler.cancel(params);
+  });
   connection.onRequest("sessionFs.readFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
@@ -6145,17 +6623,17 @@ function registerClientGlobalApiHandlers(connection, handlers) {
   });
 }
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/sdkProtocolVersion.js
 var SDK_PROTOCOL_VERSION = 3;
 function getSdkProtocolVersion() {
   return SDK_PROTOCOL_VERSION;
 }
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/session.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/session.js
 var import_node = __toESM(require_node(), 1);
 import { AsyncLocalStorage } from "node:async_hooks";
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/canvas.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/canvas.js
 var CanvasError = class _CanvasError extends Error {
   constructor(code, message) {
     super(message);
@@ -6202,7 +6680,7 @@ function createCanvas(options) {
   return new Canvas(options);
 }
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/telemetry.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/telemetry.js
 async function getTraceContext(provider) {
   if (!provider) return {};
   try {
@@ -6212,7 +6690,7 @@ async function getTraceContext(provider) {
   }
 }
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/sessionFsProvider.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/sessionFsProvider.js
 var SessionFsSqliteTransactionFailure = class extends Error {
   /** Failure classification reported to the runtime. */
   errorClass;
@@ -6383,7 +6861,7 @@ function toSqliteTransactionError(err) {
   };
 }
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/copilotRequestHandler.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/copilotRequestHandler.js
 var sharedTextDecoder = new TextDecoder("utf-8", { fatal: false });
 var sharedTextEncoder = new TextEncoder();
 var kBridge = /* @__PURE__ */ Symbol("copilotWebSocketResponseBridge");
@@ -6988,7 +7466,7 @@ var CopilotWebSocketResponseBridge = class {
   }
 };
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/types.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/types.js
 var RuntimeConnection = {
   /**
    * Spawn a runtime child process and communicate over its stdin/stdout.
@@ -7124,10 +7602,11 @@ var DisableBypassPermissionsModes = {
   AllowAutoOnly: "allow-auto-only"
 };
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/factory.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/factory.js
 var FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "completed",
   "halted",
+  "paused",
   "cancelled",
   "error"
 ]);
@@ -7224,7 +7703,7 @@ function getFactoryDefinition(handle) {
   return definition;
 }
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/session.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/session.js
 function isFactoryResumeErrorCode(value) {
   return value === "not_found" || value === "non_resumable" || value === "already_active" || value === "factory_already_running" || value === "factory_limits_invalid" || value === "factory_session_disposed" || value === "factory_storage_unavailable" || value === "factory_storage_corrupt";
 }
@@ -7238,10 +7717,14 @@ var factoryExecutionStore = new AsyncLocalStorage();
 function throwIfFactoryExecutionIsActive() {
   if (factoryExecutionStore.getStore()?.active) {
     throw new Error(
-      "factory.run and factory.resume are not allowed while a factory body is running on this call path."
+      "factory.run, factory.resume, and factory.pause are not allowed while a factory body is running on this call path."
     );
   }
 }
+function runInFactoryHelperScope(helperScope, callback) {
+  const current = factoryExecutionStore.getStore();
+  return factoryExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
+}
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
     return raw;
@@ -7285,7 +7768,7 @@ async function runFactoryParallel(thunks) {
   }
   return Promise.all(
     thunks.map(
-      (thunk) => Promise.resolve().then(() => thunk()).catch((error) => {
+      (thunk) => Promise.resolve().then(() => runInFactoryHelperScope("parallel", thunk)).catch((error) => {
         if (isFactoryFatalError(error)) {
           throw error;
         }
@@ -7304,7 +7787,10 @@ async function runFactoryPipeline(items, ...stages) {
       let previous = item;
       for (const stage of stages) {
         try {
-          previous = await stage(previous, item, index);
+          previous = await runInFactoryHelperScope(
+            "pipeline",
+            () => stage(previous, item, index)
+          );
         } catch (error) {
           if (isFactoryFatalError(error)) {
             throw error;
@@ -7446,6 +7932,7 @@ var CopilotSession = class {
   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();
@@ -7460,11 +7947,13 @@ var CopilotSession = class {
   hooks;
   transformCallbacks;
   _rpc = null;
+  _internalRpc = null;
   traceContextProvider;
   managedSettingsEnabled;
   _capabilities = {};
   openCanvasInstances = [];
   disconnected = false;
+  disconnecting = false;
   onDisconnected;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
   clientSessionApis = {};
@@ -7525,6 +8014,10 @@ var CopilotSession = class {
     }),
     getRunDetail: (runId) => this.rpc.factory.getRunDetail({ runId }),
     getRunProgress: (runId, options = {}) => this.rpc.factory.getRunProgress({ runId, ...options }),
+    pause: async (runId) => {
+      throwIfFactoryExecutionIsActive();
+      return this.rpc.factory.pause({ runId });
+    },
     cancel: async (runId) => this.rpc.factory.cancel({ runId })
   };
   /**
@@ -7623,6 +8116,13 @@ var CopilotSession = class {
     }
     return this._rpc;
   }
+  /** @internal */
+  get internalRpc() {
+    if (!this._internalRpc) {
+      this._internalRpc = createInternalSessionRpc(this.connection, this.sessionId);
+    }
+    return this._internalRpc;
+  }
   /**
    * Path to the session workspace directory when infinite sessions are enabled.
    * Contains checkpoints/, plan.md, and files/ subdirectories.
@@ -7664,6 +8164,7 @@ var CopilotSession = class {
       ...await getTraceContext(this.traceContextProvider),
       sessionId: this.sessionId,
       prompt: options.prompt,
+      source: options.source,
       displayPrompt: options.displayPrompt,
       attachments: options.attachments,
       mode: options.mode,
@@ -7722,6 +8223,10 @@ var CopilotSession = class {
       return;
     }
     this.disconnected = true;
+    for (const controller of this.pendingExternalTools.values()) {
+      controller.abort();
+    }
+    this.pendingExternalTools.clear();
     this._runOnDisconnected();
     this.eventHandlers.clear();
     this.typedEventHandlers.clear();
@@ -7825,6 +8330,15 @@ var CopilotSession = class {
           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) {
@@ -7905,16 +8419,35 @@ var CopilotSession = class {
    * @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((resolve3) => {
+          controller.signal.addEventListener("abort", () => resolve3(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,
@@ -7922,7 +8455,8 @@ var CopilotSession = class {
         arguments: args,
         availableTools,
         traceparent,
-        tracestate
+        tracestate,
+        signal: controller.signal
       });
       let result;
       if (rawResult == null) {
@@ -7934,12 +8468,12 @@ var CopilotSession = class {
       } 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);
@@ -7950,8 +8484,20 @@ var CopilotSession = class {
           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.
    * @internal
@@ -8259,6 +8805,36 @@ var CopilotSession = class {
               );
               return result2;
             },
+            pause: async (key) => {
+              if (typeof key !== "string" || key.length === 0) {
+                throw new Error("Factory pause checkpoint key must not be empty");
+              }
+              const helperScope = factoryExecutionStore.getStore()?.helperScope;
+              if (helperScope !== void 0) {
+                throw new Error(
+                  `Factory pause checkpoints are not allowed inside ${helperScope}() branches`
+                );
+              }
+              await progress.flush();
+              const response = await awaitFactoryOperation(
+                () => self.internalRpc.factory.pauseAtCheckpoint({
+                  runId: params.runId,
+                  executionToken: params.executionToken,
+                  key
+                }),
+                controller.signal
+              );
+              switch (response.action) {
+                case "continue":
+                  return;
+                case "pause":
+                  await awaitFactoryOperation(
+                    () => new Promise(() => {
+                    }),
+                    controller.signal
+                  );
+              }
+            },
             parallel: runFactoryParallel,
             pipeline: runFactoryPipeline,
             factory: async () => {
@@ -8294,11 +8870,9 @@ var CopilotSession = class {
       },
       async abort(params) {
         const controllersForRun = self.factoryAbortControllers.get(params.runId);
-        if (controllersForRun !== void 0) {
-          const reason = new DOMException("Factory run was aborted", "AbortError");
-          for (const controller of controllersForRun.values()) {
-            controller.abort(reason);
-          }
+        const controller = controllersForRun?.get(params.executionToken);
+        if (controller !== void 0) {
+          controller.abort(new DOMException("Factory run was aborted", "AbortError"));
         }
         return {};
       }
@@ -8704,13 +9278,27 @@ var CopilotSession = class {
    * ```
    */
   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]() {
@@ -8752,11 +9340,48 @@ var CopilotSession = class {
    * ```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
@@ -8948,8 +9573,7 @@ function assertFactoryStepResult(value, key) {
   });
 }
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/runtimeArtifacts.js
-import { createHash } from "node:crypto";
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/runtimeArtifacts.js
 import {
   chmodSync,
   copyFileSync,
@@ -8962,26 +9586,32 @@ import {
   rmSync,
   statSync
 } from "node:fs";
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
+
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/cliVersion.js
+var COPILOT_CLI_VERSION = "1.0.84-5";
+var COPILOT_CLI_USE_NPM_PACKAGE = false;
+
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/runtimeArtifacts.js
+var require2 = createRequire(typeof __filename === "string" ? __filename : import.meta.url);
 var 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"
 ]);
@@ -9020,14 +9650,12 @@ function collectRuntimeAssets(sources) {
         continue;
       }
       const parts = sourceRelative.split(sep);
-      let relativePath = sourceRelative;
       if (parts[0] === "prebuilds") {
         if (parts[1] !== sources.platform || parts.length < 3) {
           continue;
         }
-        relativePath = parts.slice(2).join(sep);
       }
-      assets.push({ source, relativePath });
+      assets.push({ source, relativePath: sourceRelative });
     }
   };
   visit(sources.packageRoot);
@@ -9055,15 +9683,20 @@ function defaultRuntimeCacheRoot(platform = process.platform, home = homedir(),
   const cacheDirectory = platform === "win32" ? environment.LOCALAPPDATA ?? join(home, "AppData", "Local") : platform === "darwin" ? join(home, "Library", "Caches") : environment.XDG_CACHE_HOME ?? join(home, ".cache");
   return 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 = join("prebuilds", sources.platform);
+  const wrapperRelative = join(prebuildDir, wrapperName);
+  const runtimeNodeRelative = 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 = join(cacheRoot, `${sources.platform}-${sourceFingerprint(assets)}`);
-  const installedWrapper = join(installDir, wrapperName);
-  const installedRuntimeNode = join(installDir, "runtime.node");
+  const installDir = join(cacheRoot, cacheKey);
+  const installedWrapper = join(installDir, wrapperRelative);
+  const installedRuntimeNode = join(installDir, runtimeNodeRelative);
   if (existsSync(installDir)) {
     validateRuntimeBundle(installedWrapper, installedRuntimeNode);
     makeExecutable(installedWrapper);
@@ -9077,7 +9710,7 @@ function materializeRuntimeBundle(sources, cacheRoot = defaultRuntimeCacheRoot()
       mkdirSync(dirname(destination), { recursive: true });
       copyFileSync(asset.source, destination);
     }
-    const stagedWrapper = join(stagingDir, wrapperName);
+    const stagedWrapper = join(stagingDir, wrapperRelative);
     makeExecutable(stagedWrapper);
     renameSync(stagingDir, installDir);
   } catch (error) {
@@ -9090,8 +9723,72 @@ 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 getRuntimePackageName(platform) {
+  return `@github/copilot-sdk-${platform}`;
+}
+function resolvePackageRoot(packageName, searchPaths = require2.resolve.paths(packageName) ?? []) {
+  return searchPaths.map((base) => join(base, ...packageName.split("/"))).find((candidate) => existsSync(join(candidate, "package.json")));
+}
+async function ensureRuntimeBundle(version, options = {}) {
+  const platform = options.platform ?? getRuntimePlatform();
+  if (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(
+      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 = join(packageRoot, "prebuilds", platform);
+  const wrapper = join(prebuildDir, wrapperName);
+  try {
+    validateRuntimeBundle(wrapper, 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;
+}
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/toolSet.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/toolSet.js
 var VALID_TOOL_NAME = /^[a-zA-Z0-9_-]+$/;
 function validateName(kind, name) {
   if (name === "*") {
@@ -9171,7 +9868,7 @@ var BuiltInTools = {
   ]
 };
 
-// node_modules/.pnpm/@github+copilot-sdk@1.0.13-preview.4/node_modules/@github/copilot-sdk/dist/client.js
+// node_modules/.pnpm/@github+copilot-sdk@1.0.14-preview.1/node_modules/@github/copilot-sdk/dist/client.js
 var MIN_PROTOCOL_VERSION = 3;
 var RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
 function isZodSchema(value) {
@@ -9274,6 +9971,15 @@ function toWireCustomAgents(agents) {
     return { ...rest, mcpServers: toWireMcpServers(mcpServers) };
   });
 }
+function clientInfoToWire(info) {
+  if (info == null) return void 0;
+  const wire = {};
+  if (info.applicationName) wire.editorName = info.applicationName;
+  if (info.applicationVersion) wire.editorVersion = info.applicationVersion;
+  if (info.integrationName) wire.extensionName = info.integrationName;
+  if (info.integrationVersion) wire.extensionVersion = info.integrationVersion;
+  return Object.keys(wire).length > 0 ? wire : void 0;
+}
 function toWireLargeOutput(config) {
   if (!config) return void 0;
   const { outputDirectory, ...rest } = config;
@@ -9331,53 +10037,8 @@ function getNodeExecPath() {
   }
   return process.execPath;
 }
-function getCliPlatformPackageNames() {
-  const arch = process.arch;
-  const variants = process.platform === "linux" ? ["linux", "linuxmusl"] : [process.platform];
-  return variants.map((variant) => `@github/copilot-${variant}-${arch}`);
-}
-function getBundledCliPackage() {
-  const packageNames = getCliPlatformPackageNames();
-  if (typeof import.meta.resolve === "function") {
-    for (const packageName of packageNames) {
-      try {
-        const packageEntryUrl = import.meta.resolve(packageName);
-        const packageEntryPath = fileURLToPath(packageEntryUrl);
-        return {
-          root: dirname2(packageEntryPath),
-          platform: packageName.slice("@github/copilot-".length)
-        };
-      } catch {
-      }
-    }
-    throw new Error(
-      `Could not resolve a @github/copilot platform package (tried ${packageNames.join(", ")}). Ensure @github/copilot is installed, or pass cliPath/cliUrl to CopilotClient.`
-    );
-  }
-  const req = createRequire(__filename);
-  const searchPaths = req.resolve.paths("@github/copilot") ?? [];
-  for (const base of searchPaths) {
-    for (const packageName of packageNames) {
-      const root = join2(base, ...packageName.split("/"));
-      const candidate = join2(root, "index.js");
-      if (existsSync3(candidate)) {
-        return {
-          root,
-          platform: packageName.slice("@github/copilot-".length)
-        };
-      }
-    }
-  }
-  throw new Error(
-    `Could not find a @github/copilot platform package (tried ${packageNames.join(", ")}). Searched ${searchPaths.length} paths. Ensure @github/copilot is installed, or pass cliPath/cliUrl to CopilotClient.`
-  );
-}
 function getBundledRuntimePath() {
-  const bundled = getBundledCliPackage();
-  return materializeRuntimeBundle({
-    packageRoot: bundled.root,
-    platform: bundled.platform
-  });
+  return ensureRuntimeBundle(COPILOT_CLI_VERSION);
 }
 var TeardownResilientStreamMessageWriter = class extends import_node2.StreamMessageWriter {
   suppressWriteErrors = false;
@@ -9397,10 +10058,13 @@ var CopilotClient = class _CopilotClient {
   ffiHost = null;
   connection = null;
   messageWriter = null;
+  connectionClosed = false;
   socket = null;
   runtimePort = null;
   actualHost = "localhost";
   state = "disconnected";
+  /** Shared in-flight start; concurrent callers await it instead of spawning another CLI. */
+  startPromise = null;
   sessions = /* @__PURE__ */ new Map();
   stderrBuffer = "";
   // Captures CLI stderr for error messages
@@ -9596,8 +10260,6 @@ var CopilotClient = class _CopilotClient {
       const explicitCliPath = conn.path ?? effectiveEnv.COPILOT_CLI_PATH;
       if (explicitCliPath) {
         this.resolvedCliPath = explicitCliPath;
-      } else {
-        this.resolvedCliPath = getBundledRuntimePath();
       }
     }
     const connArgs = conn.kind === "stdio" || conn.kind === "tcp" ? conn.args ?? [] : [];
@@ -9612,7 +10274,8 @@ var CopilotClient = class _CopilotClient {
       baseDirectory: options.baseDirectory,
       sessionIdleTimeoutSeconds: options.sessionIdleTimeoutSeconds ?? 0,
       enableRemoteSessions: options.enableRemoteSessions ?? false,
-      mode: options.mode ?? "copilot-cli"
+      mode: options.mode ?? "copilot-cli",
+      clientInfo: options.clientInfo
     };
     if (this.options.mode === "empty") {
       const hasPersistence = this.options.baseDirectory !== void 0 || this.sessionFsConfig !== null || // External runtimes manage their own persistence layer; the SDK
@@ -9628,17 +10291,29 @@ var CopilotClient = class _CopilotClient {
   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"
    */
   parseCliUrl(url) {
-    let cleanUrl = url.replace(/^https?:\/\//, "");
+    const cleanUrl = url.replace(/^https?:\/\//, "");
     if (/^\d+$/.test(cleanUrl)) {
       return { host: "localhost", port: parseInt(cleanUrl, 10) };
     }
+    const ipv6Match = cleanUrl.match(/^\[([^\]]+)\]:(\d+)$/);
+    if (ipv6Match) {
+      const host2 = ipv6Match[1];
+      if (!isIPv6(host2)) {
+        throw new Error(`Invalid cliUrl format: ${url}`);
+      }
+      const port2 = parseInt(ipv6Match[2], 10);
+      if (isNaN(port2) || port2 <= 0 || port2 > 65535) {
+        throw new Error(`Invalid port in cliUrl: ${url}`);
+      }
+      return { host: host2, port: port2 };
+    }
     const parts = cleanUrl.split(":");
     if (parts.length !== 2) {
       throw new Error(
-        `Invalid cliUrl format: ${url}. Expected "host:port", "http://host:port", or "port"`
+        `Invalid cliUrl format: ${url}. Expected "host:port", "[ipv6]:port", "http://host:port", or "port"`
       );
     }
     const host = parts[0] || "localhost";
@@ -9767,7 +10442,19 @@ var CopilotClient = class _CopilotClient {
     if (this.state === "connected") {
       return;
     }
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    this.startPromise = this.doStart();
+    try {
+      await this.startPromise;
+    } finally {
+      this.startPromise = null;
+    }
+  }
+  async doStart() {
     this.forceStopping = false;
+    this.connectionClosed = false;
     this.processTransportError = null;
     this.state = "connecting";
     try {
@@ -9866,7 +10553,7 @@ var CopilotClient = class _CopilotClient {
     }
     this.sessions.clear();
     this.githubTokenProviders.clear();
-    if (this.connection && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
+    if (this.connection && !this.connectionClosed && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
       void shutdownPromise.catch(() => void 0);
@@ -9955,7 +10642,7 @@ var CopilotClient = class _CopilotClient {
       const host = this.ffiHost;
       this.ffiHost = null;
       try {
-        host.dispose();
+        await host.dispose();
       } catch (error) {
         errors.push(
           new Error(
@@ -10050,11 +10737,12 @@ var CopilotClient = class _CopilotClient {
       this.cliProcess = null;
     }
     if (this.ffiHost) {
+      const host = this.ffiHost;
+      this.ffiHost = null;
       try {
-        this.ffiHost.dispose();
+        await host.dispose();
       } catch {
       }
-      this.ffiHost = null;
     }
     if (this.cliStartTimeout) {
       clearTimeout(this.cliStartTimeout);
@@ -10371,6 +11059,7 @@ var CopilotClient = class _CopilotClient {
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
+        authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
         customAgents: toWireCustomAgents(config.customAgents),
         customAgentsLocalOnly: config.customAgentsLocalOnly,
@@ -10397,6 +11086,7 @@ var CopilotClient = class _CopilotClient {
         gitHubTokenProviderRegistrationId,
         remoteSession: config.remoteSession,
         cloud: config.cloud,
+        featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
         managedSettings: config.managedSettings
@@ -10430,6 +11120,7 @@ var CopilotClient = class _CopilotClient {
       await this.updateSessionOptionsForMode(session, config);
       this.commitGitHubTokenProvider(returnedSessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
+      session?._markDisconnected();
       if (registeredId !== void 0) {
         this.sessions.delete(registeredId);
       }
@@ -10614,6 +11305,7 @@ var CopilotClient = class _CopilotClient {
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
+        authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
         customAgents: toWireCustomAgents(config.customAgents),
         customAgentsLocalOnly: config.customAgentsLocalOnly,
@@ -10632,6 +11324,7 @@ var CopilotClient = class _CopilotClient {
         gitHubTokenProviderRegistrationId,
         remoteSession: config.remoteSession,
         openCanvases: config.openCanvases,
+        featureFlags: config.featureFlags,
         expAssignments: config.expAssignments,
         enableManagedSettings: config.enableManagedSettings,
         managedSettings: config.managedSettings,
@@ -10661,6 +11354,7 @@ var CopilotClient = class _CopilotClient {
       await this.updateSessionOptionsForMode(session, config);
       this.commitGitHubTokenProvider(sessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
+      session._markDisconnected();
       this.sessions.delete(sessionId);
       if (gitHubTokenProviderRegistrationId !== void 0) {
         this.githubTokenProviders.delete(gitHubTokenProviderRegistrationId);
@@ -10776,10 +11470,17 @@ var CopilotClient = class _CopilotClient {
     const raceAgainstExit = (p) => this.processExitPromise ? Promise.race([p, this.processExitPromise]) : p;
     let serverVersion;
     try {
-      const connectParams = { token: this.effectiveConnectionToken };
+      const connectParams = {
+        token: this.effectiveConnectionToken,
+        supportedTaskKinds: ["agent", "client", "shell"]
+      };
       if (this.onGitHubTelemetry != null) {
         connectParams.enableGitHubTelemetryForwarding = true;
       }
+      const clientInfo = clientInfoToWire(this.options.clientInfo);
+      if (clientInfo != null) {
+        connectParams.clientInfo = clientInfo;
+      }
       const result = await raceAgainstExit(this.internalRpc.connect(connectParams));
       serverVersion = result.protocolVersion;
     } catch (err) {
@@ -11040,6 +11741,7 @@ var CopilotClient = class _CopilotClient {
    * Start the CLI server process
    */
   async startCLIServer() {
+    this.resolvedCliPath ??= await getBundledRuntimePath();
     return new Promise((resolve22, reject) => {
       this.stderrBuffer = "";
       const args = [...this.connectionExtraArgs, "--headless", "--no-auto-update"];
@@ -11077,7 +11779,7 @@ var CopilotClient = class _CopilotClient {
       }
       if (!existsSync3(this.resolvedCliPath)) {
         throw new Error(
-          `Copilot CLI not found at ${this.resolvedCliPath}. Ensure @github/copilot is installed.`
+          `Copilot CLI not found at ${this.resolvedCliPath}. Set COPILOT_CLI_PATH to use a custom installation.`
         );
       }
       const stdioConfig = this.connectionConfig.kind === "stdio" ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"];
@@ -11204,12 +11906,19 @@ stderr: ${stderrOutput}`
   /** Starts the in-process FFI runtime with SDK-managed typed options. */
   async startInProcessFfi() {
     const explicitEntrypoint = this.resolvedEnv.COPILOT_CLI_PATH;
-    const runtimeLibrary = explicitEntrypoint ? join2(
-      dirname2(resolve2(explicitEntrypoint)),
-      "prebuilds",
-      _CopilotClient.getNapiPrebuildsFolder(explicitEntrypoint),
-      "runtime.node"
-    ) : join2(dirname2(getBundledRuntimePath()), "runtime.node");
+    let runtimeLibrary;
+    if (explicitEntrypoint) {
+      const entrypointDirectory = dirname2(resolve2(explicitEntrypoint));
+      const adjacentRuntime = join2(entrypointDirectory, "runtime.node");
+      runtimeLibrary = existsSync3(adjacentRuntime) ? adjacentRuntime : join2(
+        entrypointDirectory,
+        "prebuilds",
+        _CopilotClient.getNapiPrebuildsFolder(explicitEntrypoint),
+        "runtime.node"
+      );
+    } else {
+      runtimeLibrary = join2(dirname2(await getBundledRuntimePath()), "runtime.node");
+    }
     const { FfiRuntimeHost: FfiRuntimeHost2 } = await Promise.resolve().then(() => (init_ffiRuntimeHost(), ffiRuntimeHost_exports));
     const environment = {};
     if (this.options.gitHubToken) {
@@ -11395,12 +12104,24 @@ stderr: ${stderrOutput}` : ""}`
         return await this.handleHooksInvoke(params);
       }
     );
-    this.connection.onClose(() => {
+    const connection = this.connection;
+    const markDisconnected = () => {
+      if (this.connection !== connection) {
+        return;
+      }
+      this.connectionClosed = true;
       this.state = "disconnected";
+      for (const session of this.sessions.values()) {
+        session._markDisconnected();
+      }
+      this.sessions.clear();
       this.githubTokenProviders.clear();
-    });
-    this.connection.onError((_error) => {
-      this.state = "disconnected";
+    };
+    this.connection.onClose(markDisconnected);
+    this.connection.onError(() => {
+      if (this.connection === connection) {
+        this.state = "disconnected";
+      }
     });
   }
   handleSessionEventNotification(notification) {