@github/copilot-sdk 1.0.3 → 1.0.5-preview.0

package/README.md

@@ -618,14 +618,17 @@ const session = await client.createSession({
 });
 ```
 
-Available section IDs: `identity`, `tone`, `tool_efficiency`, `environment_context`, `code_change_rules`, `guidelines`, `safety`, `tool_instructions`, `custom_instructions`, `runtime_instructions`, `last_instructions`. Use the `SYSTEM_MESSAGE_SECTIONS` constant for descriptions of each section.
+Available section IDs: `preamble`, `identity`, `tone`, `tool_efficiency`, `environment_context`, `code_change_rules`, `guidelines`, `safety`, `tool_instructions`, `custom_instructions`, `runtime_instructions`, `last_instructions`. Use the `SYSTEM_MESSAGE_SECTIONS` constant for descriptions of each section.
 
-Each section override supports four actions:
+`identity` and `tool_instructions` are section _groups_ that target a collection of related sub-sections as a unit. Use `preamble` to target just the identity preamble without affecting its sibling sub-sections.
+
+Each section override supports five actions:
 
 - **`replace`** — Replace the section content entirely
 - **`remove`** — Remove the section from the prompt
 - **`append`** — Add content after the existing section
 - **`prepend`** — Add content before the existing section
+- **`preserve`** — No-op that opts an individually-addressable section out of a group-level `remove`
 
 Unknown section IDs are handled gracefully: content from `replace`/`append`/`prepend` overrides is appended to additional instructions, and `remove` overrides are silently ignored.
 
@@ -684,6 +687,7 @@ information across turns. Provide a `memory` configuration on session create or
 when omitted, the runtime default applies. In the default `"copilot-cli"` client mode the
 SDK leaves `memory` unset so the runtime applies its own default, while `"empty"` mode
 defaults `memory` to disabled unless you set it explicitly.
+For more background, see [About GitHub Copilot Memory](https://docs.github.com/en/copilot/concepts/agents/copilot-memory).
 
 ```typescript
 // Enable memory for a session

package/dist/cjs/client.js

@@ -33,6 +33,7 @@ var import_rpc = require("./generated/rpc.js");
 var import_sdkProtocolVersion = require("./sdkProtocolVersion.js");
 var import_session = require("./session.js");
 var import_sessionFsProvider = require("./sessionFsProvider.js");
+var import_copilotRequestHandler = require("./copilotRequestHandler.js");
 var import_telemetry = require("./telemetry.js");
 var import_toolSet = require("./toolSet.js");
 var import_types = require("./types.js");
@@ -93,6 +94,32 @@ function toJsonSchema(parameters) {
   }
   return parameters;
 }
+const DEFAULT_PROVIDER_NAME = "default";
+function extractBearerTokenProviders(provider, providers) {
+  const callbacks = /* @__PURE__ */ new Map();
+  let wireProvider = provider;
+  if (provider?.bearerTokenProvider) {
+    const { bearerTokenProvider, ...rest } = provider;
+    callbacks.set(DEFAULT_PROVIDER_NAME, bearerTokenProvider);
+    wireProvider = {
+      ...rest,
+      hasBearerTokenProvider: true
+    };
+  }
+  let wireProviders = providers;
+  if (providers?.some((p) => p.bearerTokenProvider)) {
+    wireProviders = providers.map((p) => {
+      if (!p.bearerTokenProvider) return p;
+      const { bearerTokenProvider, ...rest } = p;
+      callbacks.set(p.name, bearerTokenProvider);
+      return {
+        ...rest,
+        hasBearerTokenProvider: true
+      };
+    });
+  }
+  return { wireProvider, wireProviders, callbacks };
+}
 function toWireMcpServers(mcpServers) {
   if (!mcpServers) return void 0;
   return Object.fromEntries(
@@ -204,10 +231,23 @@ function getBundledCliPath() {
     `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.`
   );
 }
+class TeardownResilientStreamMessageWriter extends import_node.StreamMessageWriter {
+  suppressWriteErrors = false;
+  async write(msg) {
+    try {
+      await super.write(msg);
+    } catch (error) {
+      if (!this.suppressWriteErrors) {
+        throw error;
+      }
+    }
+  }
+}
 class CopilotClient {
   cliStartTimeout = null;
   cliProcess = null;
   connection = null;
+  messageWriter = null;
   socket = null;
   runtimePort = null;
   actualHost = "localhost";
@@ -239,6 +279,8 @@ class CopilotClient {
   negotiatedProtocolVersion = null;
   /** Connection-level session filesystem config, set via constructor option. */
   sessionFsConfig = null;
+  requestHandler = null;
+  llmInferenceHandlers = {};
   /**
    * Typed server-scoped RPC methods.
    * @throws Error if the client is not connected
@@ -269,6 +311,13 @@ class CopilotClient {
     const level = this.options.logLevel?.toLowerCase();
     if (level === "debug" || level === "all") {
       process.stderr.write(`[copilot-sdk] ${message}. Elapsed=${Date.now() - startMs}ms
+`);
+    }
+  }
+  logDebug(message) {
+    const level = this.options.logLevel?.toLowerCase();
+    if (level === "debug" || level === "all") {
+      process.stderr.write(`[copilot-sdk] ${message}
 `);
     }
   }
@@ -331,6 +380,8 @@ class CopilotClient {
     this.onListModels = options.onListModels;
     this.onGetTraceContext = options.onGetTraceContext;
     this.sessionFsConfig = options.sessionFs ?? null;
+    this.requestHandler = options.requestHandler ?? null;
+    this.setupLlmInference();
     const effectiveEnv = options.env ?? process.env;
     this.resolvedEnv = effectiveEnv;
     this.resolvedCliPath = conn.kind === "stdio" || conn.kind === "tcp" ? conn.path ?? effectiveEnv.COPILOT_CLI_PATH ?? getBundledCliPath() : void 0;
@@ -410,6 +461,20 @@ class CopilotClient {
     }
     session.clientSessionApis.sessionFs = (0, import_sessionFsProvider.createSessionFsAdapter)(provider);
   }
+  setupLlmInference() {
+    if (!this.requestHandler) {
+      return;
+    }
+    this.llmInferenceHandlers = {
+      llmInference: (0, import_copilotRequestHandler.createCopilotRequestAdapter)(this.requestHandler, () => {
+        if (!this.connection) {
+          return void 0;
+        }
+        this._rpc ??= (0, import_rpc.createServerRpc)(this.connection);
+        return this._rpc;
+      })
+    };
+  }
   /**
    * Starts the CLI server and establishes a connection.
    *
@@ -447,6 +512,9 @@ class CopilotClient {
           capabilities: this.sessionFsConfig.capabilities
         });
       }
+      if (this.requestHandler) {
+        await this.connection.sendRequest("llmInference.setProvider", {});
+      }
       this.state = "connected";
     } catch (error) {
       this.state = "error";
@@ -479,7 +547,8 @@ class CopilotClient {
    */
   async stop() {
     const errors = [];
-    for (const session of this.sessions.values()) {
+    const activeSessions = [...this.sessions.values()];
+    for (const session of activeSessions) {
       const sessionId = session.sessionId;
       let lastError = null;
       for (let attempt = 1; attempt <= 3; attempt++) {
@@ -503,8 +572,10 @@ class CopilotClient {
         );
       }
     }
+    for (const session of activeSessions) {
+      session._markDisconnected();
+    }
     this.sessions.clear();
-    let runtimeShutdownCompleted = false;
     if (this.connection && this.cliProcess && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
@@ -515,7 +586,6 @@ class CopilotClient {
           RUNTIME_SHUTDOWN_TIMEOUT_MS,
           `runtime.shutdown timed out after ${RUNTIME_SHUTDOWN_TIMEOUT_MS}ms`
         );
-        runtimeShutdownCompleted = true;
         this.logDebugTiming(
           "CopilotClient.stop runtime shutdown complete",
           runtimeShutdownStart
@@ -532,6 +602,9 @@ class CopilotClient {
         );
       }
     }
+    if (this.messageWriter) {
+      this.messageWriter.suppressWriteErrors = true;
+    }
     if (this.connection) {
       try {
         this.connection.dispose();
@@ -543,6 +616,7 @@ class CopilotClient {
         );
       }
       this.connection = null;
+      this.messageWriter = null;
       this._rpc = null;
       this._internalRpc = null;
     }
@@ -570,16 +644,13 @@ class CopilotClient {
       this.cliProcess = null;
       try {
         if (child.exitCode == null && child.signalCode == null) {
-          const exitedGracefully = runtimeShutdownCompleted ? await waitForChildExit(child, RUNTIME_SHUTDOWN_TIMEOUT_MS) : false;
-          if (!exitedGracefully) {
-            child.kill();
-            if (!await waitForChildExit(child, RUNTIME_SHUTDOWN_TIMEOUT_MS)) {
-              errors.push(
-                new Error(
-                  `Timed out waiting for CLI process to exit after kill: ${RUNTIME_SHUTDOWN_TIMEOUT_MS}ms`
-                )
-              );
-            }
+          child.kill();
+          if (!await waitForChildExit(child, RUNTIME_SHUTDOWN_TIMEOUT_MS)) {
+            errors.push(
+              new Error(
+                `Timed out waiting for CLI process to exit after kill: ${RUNTIME_SHUTDOWN_TIMEOUT_MS}ms`
+              )
+            );
           }
         }
       } catch (error) {
@@ -642,13 +713,20 @@ class CopilotClient {
    */
   async forceStop() {
     this.forceStopping = true;
+    for (const session of this.sessions.values()) {
+      session._markDisconnected();
+    }
     this.sessions.clear();
+    if (this.messageWriter) {
+      this.messageWriter.suppressWriteErrors = true;
+    }
     if (this.connection) {
       try {
         this.connection.dispose();
       } catch {
       }
       this.connection = null;
+      this.messageWriter = null;
       this._rpc = null;
       this._internalRpc = null;
     }
@@ -834,6 +912,11 @@ class CopilotClient {
     const callerSessionId = config.sessionId;
     const useServerGeneratedId = config.cloud != null && callerSessionId == null;
     const localSessionId = useServerGeneratedId ? void 0 : callerSessionId ?? (0, import_node_crypto.randomUUID)();
+    const {
+      wireProvider: bearerWireProvider,
+      wireProviders: bearerWireProviders,
+      callbacks: bearerTokenCallbacks
+    } = extractBearerTokenProviders(config.provider, config.providers);
     const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(
       config.systemMessage
     );
@@ -847,6 +930,9 @@ class CopilotClient {
       s.registerTools(config.tools);
       s.registerCanvases(config.canvases);
       s.registerCommands(config.commands);
+      if (bearerTokenCallbacks.size > 0) {
+        s.registerBearerTokenProviders(bearerTokenCallbacks);
+      }
       s.registerPermissionHandler(config.onPermissionRequest);
       if (config.onUserInputRequest) {
         s.registerUserInputHandler(config.onUserInputRequest);
@@ -910,8 +996,9 @@ class CopilotClient {
         availableTools: toolFilterOptions.availableTools,
         excludedTools: toolFilterOptions.excludedTools,
         toolFilterPrecedence: toolFilterOptions.toolFilterPrecedence,
-        provider: config.provider,
-        providers: config.providers,
+        provider: bearerWireProvider,
+        capi: config.capi,
+        providers: bearerWireProviders,
         models: config.models,
         enableSessionTelemetry: config.enableSessionTelemetry,
         modelCapabilities: config.modelCapabilities,
@@ -950,7 +1037,8 @@ class CopilotClient {
         memory: config.memory,
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
-        cloud: config.cloud
+        cloud: config.cloud,
+        expAssignments: config.expAssignments
       });
       const {
         sessionId: returnedSessionId,
@@ -1017,6 +1105,14 @@ class CopilotClient {
     session.registerTools(config.tools);
     session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
+    const {
+      wireProvider: bearerWireProvider,
+      wireProviders: bearerWireProviders,
+      callbacks: bearerTokenCallbacks
+    } = extractBearerTokenProviders(config.provider, config.providers);
+    if (bearerTokenCallbacks.size > 0) {
+      session.registerBearerTokenProviders(bearerTokenCallbacks);
+    }
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
       session.registerUserInputHandler(config.onUserInputRequest);
@@ -1078,8 +1174,9 @@ class CopilotClient {
           name: cmd.name,
           description: cmd.description
         })),
-        provider: config.provider,
-        providers: config.providers,
+        provider: bearerWireProvider,
+        capi: config.capi,
+        providers: bearerWireProviders,
         models: config.models,
         modelCapabilities: config.modelCapabilities,
         largeOutput: toWireLargeOutput(config.largeOutput),
@@ -1119,7 +1216,8 @@ class CopilotClient {
         continuePendingWork: config.continuePendingWork,
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
-        openCanvases: config.openCanvases
+        openCanvases: config.openCanvases,
+        expAssignments: config.expAssignments
       });
       const { workspacePath, capabilities, openCanvases } = response;
       session["_workspacePath"] = workspacePath;
@@ -1661,13 +1759,21 @@ stderr: ${stderrOutput}`
       throw new Error("CLI process not started");
     }
     this.cliProcess.stdin?.on("error", (err) => {
-      if (!this.forceStopping) {
-        throw err;
+      if (this.forceStopping) {
+        return;
+      }
+      this.state = "error";
+      const reason = err instanceof Error ? err.stack ?? err.message : String(err);
+      this.logDebug(`stdin pipe error: ${reason}`);
+      try {
+        this.connection?.dispose();
+      } catch {
       }
     });
+    this.messageWriter = new TeardownResilientStreamMessageWriter(this.cliProcess.stdin);
     this.connection = (0, import_node.createMessageConnection)(
       new import_node.StreamMessageReader(this.cliProcess.stdout),
-      new import_node.StreamMessageWriter(this.cliProcess.stdin)
+      this.messageWriter
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -1679,9 +1785,10 @@ stderr: ${stderrOutput}`
     if (this.cliProcess) {
       throw new Error("CLI child process was unexpectedly started in parent process mode");
     }
+    this.messageWriter = new TeardownResilientStreamMessageWriter(process.stdout);
     this.connection = (0, import_node.createMessageConnection)(
       new import_node.StreamMessageReader(process.stdin),
-      new import_node.StreamMessageWriter(process.stdout)
+      this.messageWriter
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -1701,9 +1808,10 @@ stderr: ${stderrOutput}`
       }, 1e4);
       this.socket.connect(this.runtimePort, this.actualHost, () => {
         clearTimeout(connectionTimeout);
+        this.messageWriter = new TeardownResilientStreamMessageWriter(this.socket);
         this.connection = (0, import_node.createMessageConnection)(
           new import_node.StreamMessageReader(this.socket),
-          new import_node.StreamMessageWriter(this.socket)
+          this.messageWriter
         );
         this.attachConnectionHandlers();
         this.connection.listen();
@@ -1751,6 +1859,7 @@ stderr: ${stderrOutput}`
       if (!session) throw new Error(`No session found for sessionId: ${sessionId}`);
       return session.clientSessionApis;
     });
+    (0, import_rpc.registerClientGlobalApiHandlers)(this.connection, this.llmInferenceHandlers);
     this.connection.onClose(() => {
       this.state = "disconnected";
     });