@github/copilot-sdk 1.0.13-preview.6 → 1.0.14-preview.0

package/README.md

@@ -267,11 +267,26 @@ Send a message to the session. Returns immediately after the message is queued;
 **Options:**
 
 - `prompt: string` - The message/prompt to send
+- `source?: MessageSource` - `"user"`, `"system"`, or `` `agent-${string}` `` provenance; omitted by default
 - `attachments?: Array<{type, path, displayName}>` - File attachments
 - `mode?: "enqueue" | "immediate"` - Delivery mode
 
 Returns the message ID.
 
+Use `source: "system"` for automated messages from your application:
+
+```typescript
+await session.send({ prompt: "Context updated", source: "system" });
+```
+
+For a message from another agent, use its trusted sender ID:
+
+```typescript
+await session.send({ prompt: "Review complete", source: "agent-reviewer-id" });
+```
+
+Source is independent of delivery mode. Leaving it unset preserves the existing human-message payload; it does not set billing flags or use the notification API.
+
 ##### `sendAndWait(options: MessageOptions, timeout?: number): Promise<AssistantMessageEvent | undefined>`
 
 Send a message and wait until the session becomes idle.
@@ -279,6 +294,7 @@ Send a message and wait until the session becomes idle.
 **Options:**
 
 - `prompt: string` - The message/prompt to send
+- `source?: MessageSource` - Same optional provenance as `send`
 - `attachments?: Array<{type, path, displayName}>` - File attachments
 - `mode?: "enqueue" | "immediate"` - Delivery mode
 - `timeout?: number` - Optional timeout in milliseconds
@@ -319,6 +335,32 @@ const unsubscribe = session.on((event) => {
 unsubscribe();
 ```
 
+##### `setModel(model: string, options?): Promise<void>`
+
+Change the model for this session. The new model takes effect for the next message; conversation history is preserved.
+
+**Options:**
+
+- `reasoningEffort?: string` - Reasoning effort level
+- `autoTier?: AutoTier | null` - Auto routing preference to stage together with selecting `auto`. Pass `null` to return to the provider's default Auto routing; omit it to leave the current preference unchanged.
+
+##### `setAutoTier(autoTier: AutoTier | null): Promise<ModelSwitchAutoTierResult>`
+
+Change the Auto routing preference without changing the selected model. Pass `null` to return to the provider's default Auto routing.
+
+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, so a `pending` status confirms acceptance rather than effect. Only the most recent request survives.
+
+Watch for the outcome through the `session.model_change` event on success or the ephemeral `session.auto_tier_switch_failed` event on failure, and read the authoritative state at any time with `session.rpc.model.getCurrent()`.
+
+```typescript
+const result = await session.setAutoTier("intelligence");
+if (result.status === "pending") {
+    // Accepted, but not yet in effect.
+}
+```
+
+See [Auto tier persistence](../docs/features/session-persistence.md#auto-tier-persistence) for the full lifecycle rules.
+
 ##### `abort(): Promise<void>`
 
 Abort the currently processing message in this session.

package/dist/cjs/cliVersion.js

@@ -22,7 +22,7 @@ __export(cliVersion_exports, {
   COPILOT_CLI_VERSION: () => COPILOT_CLI_VERSION
 });
 module.exports = __toCommonJS(cliVersion_exports);
-const COPILOT_CLI_VERSION = "1.0.83-3";
+const COPILOT_CLI_VERSION = "1.0.84-5";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/client.js

@@ -236,10 +236,13 @@ 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
@@ -617,7 +620,19 @@ 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 {
@@ -716,7 +731,7 @@ 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);
@@ -805,7 +820,7 @@ class CopilotClient {
       const host = this.ffiHost;
       this.ffiHost = null;
       try {
-        host.dispose();
+        await host.dispose();
       } catch (error) {
         errors.push(
           new Error(
@@ -900,11 +915,12 @@ 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);
@@ -1221,6 +1237,7 @@ 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,
@@ -1281,6 +1298,7 @@ class CopilotClient {
       await this.updateSessionOptionsForMode(session, config);
       this.commitGitHubTokenProvider(returnedSessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
+      session?._markDisconnected();
       if (registeredId !== void 0) {
         this.sessions.delete(registeredId);
       }
@@ -1465,6 +1483,7 @@ 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,
@@ -1513,6 +1532,7 @@ 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);
@@ -1628,7 +1648,10 @@ 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;
       }
@@ -2259,12 +2282,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) {

package/dist/cjs/ffiRuntimeHost.js

@@ -37,6 +37,7 @@ var import_node_path = require("node:path");
 var import_node_stream = require("node:stream");
 const SYMBOL_PREFIX = "copilot_runtime_";
 const KEEP_ALIVE_INTERVAL_MS = 1 << 30;
+const CLEANUP_RETRY_INTERVAL_MS = 100;
 let loadedLibraryPath;
 let loadedLibrary;
 function loadLibrary(libraryPath) {
@@ -129,12 +130,16 @@ class FfiRuntimeHost {
   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. */
@@ -156,49 +161,65 @@ class FfiRuntimeHost {
   }
   /** 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) {
@@ -237,41 +258,105 @@ class FfiRuntimeHost {
   }
   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();
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node: