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

package/dist/client.js

@@ -15,11 +15,13 @@ import {
 import {
   createServerRpc,
   createInternalServerRpc,
+  registerClientGlobalApiHandlers,
   registerClientSessionApiHandlers
 } from "./generated/rpc.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
 import { CopilotSession } from "./session.js";
 import { createSessionFsAdapter } from "./sessionFsProvider.js";
+import { createCopilotRequestAdapter } from "./copilotRequestHandler.js";
 import { getTraceContext } from "./telemetry.js";
 import { ToolSet } from "./toolSet.js";
 import { defaultJoinSessionPermissionHandler } from "./types.js";
@@ -79,6 +81,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(
@@ -190,10 +218,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 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";
@@ -225,6 +266,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
@@ -255,6 +298,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}
 `);
     }
   }
@@ -317,6 +367,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;
@@ -396,6 +448,20 @@ class CopilotClient {
     }
     session.clientSessionApis.sessionFs = createSessionFsAdapter(provider);
   }
+  setupLlmInference() {
+    if (!this.requestHandler) {
+      return;
+    }
+    this.llmInferenceHandlers = {
+      llmInference: createCopilotRequestAdapter(this.requestHandler, () => {
+        if (!this.connection) {
+          return void 0;
+        }
+        this._rpc ??= createServerRpc(this.connection);
+        return this._rpc;
+      })
+    };
+  }
   /**
    * Starts the CLI server and establishes a connection.
    *
@@ -433,6 +499,9 @@ class CopilotClient {
           capabilities: this.sessionFsConfig.capabilities
         });
       }
+      if (this.requestHandler) {
+        await this.connection.sendRequest("llmInference.setProvider", {});
+      }
       this.state = "connected";
     } catch (error) {
       this.state = "error";
@@ -465,7 +534,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++) {
@@ -489,8 +559,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();
@@ -501,7 +573,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
@@ -518,6 +589,9 @@ class CopilotClient {
         );
       }
     }
+    if (this.messageWriter) {
+      this.messageWriter.suppressWriteErrors = true;
+    }
     if (this.connection) {
       try {
         this.connection.dispose();
@@ -529,6 +603,7 @@ class CopilotClient {
         );
       }
       this.connection = null;
+      this.messageWriter = null;
       this._rpc = null;
       this._internalRpc = null;
     }
@@ -556,16 +631,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) {
@@ -628,13 +700,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;
     }
@@ -820,6 +899,11 @@ class CopilotClient {
     const callerSessionId = config.sessionId;
     const useServerGeneratedId = config.cloud != null && callerSessionId == null;
     const localSessionId = useServerGeneratedId ? void 0 : callerSessionId ?? randomUUID();
+    const {
+      wireProvider: bearerWireProvider,
+      wireProviders: bearerWireProviders,
+      callbacks: bearerTokenCallbacks
+    } = extractBearerTokenProviders(config.provider, config.providers);
     const { wirePayload: wireSystemMessage, transformCallbacks } = extractTransformCallbacks(
       config.systemMessage
     );
@@ -833,6 +917,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);
@@ -896,8 +983,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,
@@ -936,7 +1024,8 @@ class CopilotClient {
         memory: config.memory,
         gitHubToken: config.gitHubToken,
         remoteSession: config.remoteSession,
-        cloud: config.cloud
+        cloud: config.cloud,
+        expAssignments: config.expAssignments
       });
       const {
         sessionId: returnedSessionId,
@@ -1003,6 +1092,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);
@@ -1064,8 +1161,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),
@@ -1105,7 +1203,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;
@@ -1647,13 +1746,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 = createMessageConnection(
       new StreamMessageReader(this.cliProcess.stdout),
-      new StreamMessageWriter(this.cliProcess.stdin)
+      this.messageWriter
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -1665,9 +1772,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 = createMessageConnection(
       new StreamMessageReader(process.stdin),
-      new StreamMessageWriter(process.stdout)
+      this.messageWriter
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -1687,9 +1795,10 @@ stderr: ${stderrOutput}`
       }, 1e4);
       this.socket.connect(this.runtimePort, this.actualHost, () => {
         clearTimeout(connectionTimeout);
+        this.messageWriter = new TeardownResilientStreamMessageWriter(this.socket);
         this.connection = createMessageConnection(
           new StreamMessageReader(this.socket),
-          new StreamMessageWriter(this.socket)
+          this.messageWriter
         );
         this.attachConnectionHandlers();
         this.connection.listen();
@@ -1737,6 +1846,7 @@ stderr: ${stderrOutput}`
       if (!session) throw new Error(`No session found for sessionId: ${sessionId}`);
       return session.clientSessionApis;
     });
+    registerClientGlobalApiHandlers(this.connection, this.llmInferenceHandlers);
     this.connection.onClose(() => {
       this.state = "disconnected";
     });

package/dist/copilotRequestHandler.d.ts

@@ -0,0 +1,82 @@
+import type { LlmInferenceHeaders } from "./generated/rpc.js";
+declare const kSuppressCloseOnDispose: unique symbol;
+/**
+ * Per-request context handed to every {@link CopilotRequestHandler} hook.
+ *
+ * @experimental
+ */
+export interface CopilotRequestContext {
+    readonly requestId: string;
+    readonly sessionId?: string;
+    readonly transport: "http" | "websocket";
+    url: string;
+    headers: LlmInferenceHeaders;
+    readonly signal: AbortSignal;
+}
+/**
+ * Terminal status for a callback-owned WebSocket connection.
+ *
+ * @experimental
+ */
+export declare class CopilotWebSocketCloseStatus {
+    readonly description?: string | undefined;
+    readonly errorCode?: string | undefined;
+    readonly error?: Error | undefined;
+    static readonly normalClosure: CopilotWebSocketCloseStatus;
+    constructor(description?: string | undefined, errorCode?: string | undefined, error?: Error | undefined);
+}
+/**
+ * Lower-level WebSocket handler with no upstream connection.
+ *
+ * This is the abstract base shared by all WebSocket handlers. It does not open
+ * or forward to any upstream server on its own — subclass it directly only when
+ * you want to service a fully synthetic connection yourself (e.g. answer the
+ * runtime without any real backend). For the common case of mutating and
+ * forwarding traffic to the real upstream, subclass {@link CopilotWebSocketForwarder}
+ * instead, which connects upstream and forwards by default.
+ *
+ * @experimental
+ */
+export declare abstract class CopilotWebSocketHandler implements AsyncDisposable {
+    #private;
+    [kSuppressCloseOnDispose]: boolean;
+    protected readonly context: CopilotRequestContext;
+    protected constructor(context: CopilotRequestContext);
+    sendResponseMessage(data: string | Uint8Array): Promise<void>;
+    close(status?: CopilotWebSocketCloseStatus): Promise<void>;
+    abstract sendRequestMessage(data: string | Uint8Array): Promise<void> | void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * WebSocket handler that connects to the real upstream and forwards traffic by
+ * default. This is the type returned by the default
+ * {@link CopilotRequestHandler.openWebSocket}.
+ *
+ * Override nothing to get full pass-through. To mutate traffic, subclass this
+ * type and override a message hook, then call `super` to keep forwarding to the
+ * upstream. (Subclassing {@link CopilotWebSocketHandler} instead would drop
+ * forwarding entirely.)
+ *
+ * @experimental
+ */
+export declare class CopilotWebSocketForwarder extends CopilotWebSocketHandler {
+    #private;
+    constructor(context: CopilotRequestContext);
+    sendRequestMessage(data: string | Uint8Array): void;
+    close(status?: CopilotWebSocketCloseStatus): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * Base class for SDK consumers who want to observe or mutate the outbound
+ * model-layer requests the runtime issues (for both CAPI and BYOK providers).
+ * Subclass and override {@link sendRequest} or {@link openWebSocket}; an
+ * instance that overrides nothing is a transparent pass-through.
+ *
+ * @experimental
+ */
+export declare class CopilotRequestHandler {
+    #private;
+    protected sendRequest(request: Request, ctx: CopilotRequestContext): Promise<Response>;
+    protected openWebSocket(ctx: CopilotRequestContext): Promise<CopilotWebSocketHandler>;
+}
+export {};