@github/copilot-sdk 1.0.2 → 1.0.4

package/dist/cjs/generated/rpc.js

@@ -22,6 +22,7 @@ __export(rpc_exports, {
   createInternalSessionRpc: () => createInternalSessionRpc,
   createServerRpc: () => createServerRpc,
   createSessionRpc: () => createSessionRpc,
+  registerClientGlobalApiHandlers: () => registerClientGlobalApiHandlers,
   registerClientSessionApiHandlers: () => registerClientSessionApiHandlers
 });
 module.exports = __toCommonJS(rpc_exports);
@@ -63,7 +64,35 @@ function createServerRpc(connection) {
        *
        * @returns Quota usage snapshots for the resolved user, keyed by quota type.
        */
-      getQuota: async (params) => connection.sendRequest("account.getQuota", params)
+      getQuota: async (params) => connection.sendRequest("account.getQuota", params),
+      /**
+       * Gets the currently active authentication credentials from the global auth manager.
+       *
+       * @returns Current authentication state
+       */
+      getCurrentAuth: async () => connection.sendRequest("account.getCurrentAuth", {}),
+      /**
+       * Gets all authenticated users available for account switching.
+       *
+       * @returns List of all authenticated users
+       */
+      getAllUsers: async () => connection.sendRequest("account.getAllUsers", {}),
+      /**
+       * Stores authentication credentials after successful login (e.g., device code flow).
+       *
+       * @param params Credentials to store after successful authentication
+       *
+       * @returns Result of a successful login; throws on failure
+       */
+      login: async (params) => connection.sendRequest("account.login", params),
+      /**
+       * Removes user authentication from keychain and persisted state.
+       *
+       * @param params User to log out
+       *
+       * @returns Logout result indicating if more users remain
+       */
+      logout: async (params) => connection.sendRequest("account.logout", params)
     },
     secrets: {
       /**
@@ -308,6 +337,31 @@ function createServerRpc(connection) {
       setProvider: async (params) => connection.sendRequest("sessionFs.setProvider", params)
     },
     /** @experimental */
+    llmInference: {
+      /**
+       * Registers an SDK client as the LLM inference callback provider.
+       *
+       * @returns Indicates whether the calling client was registered as the LLM inference provider.
+       */
+      setProvider: async () => connection.sendRequest("llmInference.setProvider", {}),
+      /**
+       * Delivers the response head (status + headers) for an in-flight request, correlated by the requestId the runtime supplied in httpRequestStart. Must be called exactly once per request before any httpResponseChunk frames.
+       *
+       * @param params Response head.
+       *
+       * @returns Whether the start frame was accepted.
+       */
+      httpResponseStart: async (params) => connection.sendRequest("llmInference.httpResponseStart", params),
+      /**
+       * Delivers a body byte range (or a terminal transport error) for an in-flight response, correlated by requestId. Set `end` true on the last chunk. When `error` is set the response terminates with a transport-level failure and the runtime raises an APIConnectionError.
+       *
+       * @param params A response body chunk or terminal error.
+       *
+       * @returns Whether the chunk was accepted.
+       */
+      httpResponseChunk: async (params) => connection.sendRequest("llmInference.httpResponseChunk", params)
+    },
+    /** @experimental */
     sessions: {
       /**
        * Creates or resumes a local session and returns the opened session ID.
@@ -1067,10 +1121,18 @@ function createSessionRpc(connection, sessionId) {
       isServerRunning: async (params) => connection.sendRequest("session.mcp.isServerRunning", { sessionId, ...params }),
       /** @experimental */
       oauth: {
+        /**
+         * Resolves a pending MCP OAuth request with a host-provided token or cancellation. The pending request is emitted as mcp.oauth_required with the data necessary to authorize the request.
+         *
+         * @param params Pending MCP OAuth request ID and host-provided token or cancellation response.
+         *
+         * @returns Indicates whether the pending MCP OAuth response was accepted.
+         */
+        handlePendingRequest: async (params) => connection.sendRequest("session.mcp.oauth.handlePendingRequest", { sessionId, ...params }),
         /**
          * Starts OAuth authentication for a remote MCP server.
          *
-         * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, and the callback success-page copy.
+         * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.
          *
          * @returns OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
          */
@@ -1148,7 +1210,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns A snapshot of the provider endpoint the session is currently configured to talk to.
        */
-      getEndpoint: async (params) => connection.sendRequest("session.provider.getEndpoint", { sessionId, ...params })
+      getEndpoint: async (params) => connection.sendRequest("session.provider.getEndpoint", { sessionId, ...params }),
+      /**
+       * Adds BYOK providers and/or models to the session's registry at runtime, extending the additive registry built from the session's `providers`/`models` options. Both fields are optional, so a call may add providers only, models only, or both. Within a single call providers are registered before models, so a model may reference a provider added in the same call; across calls a model may reference any provider already registered (from session creation or a prior add). A model whose referenced provider is not registered by the end of the call is rejected. Newly added models become selectable via `model.list` / `model.switchTo` and are inherited by sub-agents spawned afterwards.
+       *
+       * @param params BYOK providers and/or models to add to the session's registry at runtime. Both fields are optional; provide providers, models, or both.
+       *
+       * @returns The selectable model entries synthesized for the models added by this call.
+       */
+      add: async (params) => connection.sendRequest("session.provider.add", { sessionId, ...params })
     },
     /** @experimental */
     options: {
@@ -1831,7 +1901,7 @@ function createInternalSessionRpc(connection, sessionId) {
       /** @experimental */
       oauth: {
         /**
-         * Responds to a pending MCP OAuth provider request. Marked internal because the `provider` argument is an in-process OAuthClientProvider instance that cannot be carried over the wire; the public OAuth surface will route the response through a wire-clean handshake once the CLI moves on top of the SDK.
+         * Responds to a pending MCP OAuth request with an in-process provider. This internal CLI-only API accepts a live OAuthClientProvider instance and cannot be used over the SDK JSON-RPC boundary. Use session.mcp.oauth.handlePendingRequest instead for the public SDK-safe response path.
          *
          * @param params MCP OAuth request id and optional provider response.
          *
@@ -1843,6 +1913,11 @@ function createInternalSessionRpc(connection, sessionId) {
   };
 }
 function registerClientSessionApiHandlers(connection, getHandlers) {
+  connection.onRequest("providerToken.getToken", async (params) => {
+    const handler = getHandlers(params.sessionId).providerToken;
+    if (!handler) throw new Error(`No providerToken handler registered for session: ${params.sessionId}`);
+    return handler.getToken(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}`);
@@ -1919,11 +1994,24 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     return handler.invoke(params);
   });
 }
+function registerClientGlobalApiHandlers(connection, handlers) {
+  connection.onRequest("llmInference.httpRequestStart", async (params) => {
+    const handler = handlers.llmInference;
+    if (!handler) throw new Error("No llmInference client-global handler registered");
+    return handler.httpRequestStart(params);
+  });
+  connection.onRequest("llmInference.httpRequestChunk", async (params) => {
+    const handler = handlers.llmInference;
+    if (!handler) throw new Error("No llmInference client-global handler registered");
+    return handler.httpRequestChunk(params);
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createInternalServerRpc,
   createInternalSessionRpc,
   createServerRpc,
   createSessionRpc,
+  registerClientGlobalApiHandlers,
   registerClientSessionApiHandlers
 });

package/dist/cjs/index.js

@@ -22,7 +22,11 @@ __export(index_exports, {
   Canvas: () => import_canvas.Canvas,
   CanvasError: () => import_canvas.CanvasError,
   CopilotClient: () => import_client.CopilotClient,
+  CopilotRequestHandler: () => import_types2.CopilotRequestHandler,
   CopilotSession: () => import_session.CopilotSession,
+  CopilotWebSocketCloseStatus: () => import_types2.CopilotWebSocketCloseStatus,
+  CopilotWebSocketForwarder: () => import_types2.CopilotWebSocketForwarder,
+  CopilotWebSocketHandler: () => import_types2.CopilotWebSocketHandler,
   RuntimeConnection: () => import_types.RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS: () => import_types2.SYSTEM_MESSAGE_SECTIONS,
   ToolSet: () => import_toolSet.ToolSet,
@@ -45,7 +49,11 @@ var import_types2 = require("./types.js");
   Canvas,
   CanvasError,
   CopilotClient,
+  CopilotRequestHandler,
   CopilotSession,
+  CopilotWebSocketCloseStatus,
+  CopilotWebSocketForwarder,
+  CopilotWebSocketHandler,
   RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS,
   ToolSet,

package/dist/cjs/session.js

@@ -38,7 +38,7 @@ function isOpenCanvasInstance(value) {
     return false;
   }
   const instance = value;
-  return typeof instance.instanceId === "string" && instance.instanceId.length > 0 && typeof instance.extensionId === "string" && instance.extensionId.length > 0 && typeof instance.canvasId === "string" && instance.canvasId.length > 0 && typeof instance.reopen === "boolean" && (instance.availability === "ready" || instance.availability === "stale");
+  return typeof instance.instanceId === "string" && instance.instanceId.length > 0 && typeof instance.extensionId === "string" && instance.extensionId.length > 0 && typeof instance.canvasId === "string" && instance.canvasId.length > 0;
 }
 class CopilotSession {
   /**
@@ -63,6 +63,7 @@ class CopilotSession {
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
   canvases = /* @__PURE__ */ new Map();
+  bearerTokenProviders = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
   permissionHandler;
   userInputHandler;
@@ -75,6 +76,7 @@ class CopilotSession {
   traceContextProvider;
   _capabilities = {};
   openCanvasInstances = [];
+  disconnected = false;
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
   clientSessionApis = {};
   /**
@@ -178,6 +180,21 @@ class CopilotSession {
       unsubscribe();
     }
   }
+  /** @internal */
+  _markDisconnected() {
+    this.disconnected = true;
+    this.eventHandlers.clear();
+    this.typedEventHandlers.clear();
+    this.toolHandlers.clear();
+    this.permissionHandler = void 0;
+    this.userInputHandler = void 0;
+    this.elicitationHandler = void 0;
+    this.exitPlanModeHandler = void 0;
+    this.autoModeSwitchHandler = void 0;
+    this.commandHandlers.clear();
+    this.canvases.clear();
+    this.transformCallbacks?.clear();
+  }
   on(eventTypeOrHandler, handler) {
     if (typeof eventTypeOrHandler === "string" && handler) {
       const eventType = eventTypeOrHandler;
@@ -231,6 +248,9 @@ class CopilotSession {
    * @internal
    */
   _handleBroadcastEvent(event) {
+    if (this.disconnected) {
+      return;
+    }
     if (event.type === "external_tool.requested") {
       const { requestId, toolName } = event.data;
       const args = event.data.arguments;
@@ -336,8 +356,14 @@ class CopilotSession {
       } else {
         result = JSON.stringify(rawResult);
       }
+      if (this.disconnected) {
+        return;
+      }
       await this.rpc.tools.handlePendingToolCall({ requestId, result });
     } catch (error) {
+      if (this.disconnected) {
+        return;
+      }
       const message = error instanceof Error ? error.message : String(error);
       try {
         await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
@@ -360,8 +386,14 @@ class CopilotSession {
       if (result.kind === "no-result") {
         return;
       }
+      if (this.disconnected) {
+        return;
+      }
       await this.rpc.permissions.handlePendingPermissionRequest({ requestId, result });
     } catch (_error) {
+      if (this.disconnected) {
+        return;
+      }
       try {
         await this.rpc.permissions.handlePendingPermissionRequest({
           requestId,
@@ -397,8 +429,14 @@ class CopilotSession {
     }
     try {
       await handler({ sessionId: this.sessionId, command, commandName, args });
+      if (this.disconnected) {
+        return;
+      }
       await this.rpc.commands.handlePendingCommand({ requestId });
     } catch (error) {
+      if (this.disconnected) {
+        return;
+      }
       const message = error instanceof Error ? error.message : String(error);
       try {
         await this.rpc.commands.handlePendingCommand({ requestId, error: message });
@@ -494,6 +532,43 @@ class CopilotSession {
       }
     };
   }
+  /**
+   * Registers per-provider {@link GetBearerToken} callbacks for BYOK providers
+   * configured with managed-identity / on-demand bearer-token auth.
+   *
+   * The runtime never receives the callback itself; the SDK strips it from the
+   * provider config and instead sends `hasBearerTokenProvider: true`. When the
+   * runtime needs a token it issues a session-scoped `providerToken.getToken`
+   * request, which this handler routes to the matching per-provider callback.
+   *
+   * @param providers - Map of provider name → callback, or undefined/empty to clear.
+   * @internal This method is called internally when creating/resuming a session.
+   */
+  registerBearerTokenProviders(providers) {
+    this.bearerTokenProviders.clear();
+    if (!providers || providers.size === 0) {
+      delete this.clientSessionApis.providerToken;
+      return;
+    }
+    for (const [name, callback] of providers) {
+      this.bearerTokenProviders.set(name, callback);
+    }
+    const self = this;
+    this.clientSessionApis.providerToken = {
+      async getToken(params) {
+        const callback = self.bearerTokenProviders.get(params.providerName);
+        if (!callback) {
+          throw new Error(
+            `No bearer-token provider registered for provider "${params.providerName}"`
+          );
+        }
+        const token = await callback({
+          providerName: params.providerName
+        });
+        return { token };
+      }
+    };
+  }
   /**
    * Registers command handlers for this session.
    *
@@ -848,17 +923,13 @@ class CopilotSession {
    * ```
    */
   async disconnect() {
+    if (this.disconnected) {
+      return;
+    }
     await this.connection.sendRequest("session.destroy", {
       sessionId: this.sessionId
     });
-    this.eventHandlers.clear();
-    this.typedEventHandlers.clear();
-    this.toolHandlers.clear();
-    this.permissionHandler = void 0;
-    this.userInputHandler = void 0;
-    this.elicitationHandler = void 0;
-    this.exitPlanModeHandler = void 0;
-    this.autoModeSwitchHandler = void 0;
+    this._markDisconnected();
   }
   /** Enables `await using session = ...` syntax for automatic cleanup. */
   async [Symbol.asyncDispose]() {

package/dist/cjs/types.js

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var types_exports = {};
 __export(types_exports, {
+  CopilotRequestHandler: () => import_copilotRequestHandler.CopilotRequestHandler,
+  CopilotWebSocketCloseStatus: () => import_copilotRequestHandler.CopilotWebSocketCloseStatus,
+  CopilotWebSocketForwarder: () => import_copilotRequestHandler.CopilotWebSocketForwarder,
+  CopilotWebSocketHandler: () => import_copilotRequestHandler.CopilotWebSocketHandler,
   RuntimeConnection: () => RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS: () => SYSTEM_MESSAGE_SECTIONS,
   approveAll: () => approveAll,
@@ -28,6 +32,7 @@ __export(types_exports, {
 });
 module.exports = __toCommonJS(types_exports);
 var import_sessionFsProvider = require("./sessionFsProvider.js");
+var import_copilotRequestHandler = require("./copilotRequestHandler.js");
 const RuntimeConnection = {
   /**
    * Spawn a runtime child process and communicate over its stdin/stdout.
@@ -102,7 +107,10 @@ function defineTool(name, config) {
   return { name, ...config };
 }
 const SYSTEM_MESSAGE_SECTIONS = {
-  identity: { description: "Agent identity preamble and mode statement" },
+  preamble: { description: "Agent identity preamble and mode statement" },
+  identity: {
+    description: "Section group covering the identity preamble and its sibling sub-sections (tone, tool efficiency, etc.)"
+  },
   tone: { description: "Response style, conciseness rules, output formatting preferences" },
   tool_efficiency: { description: "Tool usage patterns, parallel calling, batching guidelines" },
   environment_context: { description: "CWD, OS, git root, directory listing, available tools" },
@@ -124,6 +132,10 @@ const defaultJoinSessionPermissionHandler = () => ({
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CopilotRequestHandler,
+  CopilotWebSocketCloseStatus,
+  CopilotWebSocketForwarder,
+  CopilotWebSocketHandler,
   RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS,
   approveAll,

package/dist/client.d.ts

@@ -1,43 +1,11 @@
 import { createServerRpc } from "./generated/rpc.js";
 import { CopilotSession } from "./session.js";
 import type { CopilotClientOptions, GetAuthStatusResponse, GetStatusResponse, ModelInfo, ResumeSessionConfig, SessionConfig, SessionLifecycleEventType, SessionLifecycleHandler, SessionListFilter, SessionMetadata, TypedSessionLifecycleHandler } from "./types.js";
-/**
- * Main client for interacting with the Copilot CLI.
- *
- * The CopilotClient manages the connection to the Copilot CLI server and provides
- * methods to create and manage conversation sessions. It can either spawn a CLI
- * server process or connect to an existing server.
- *
- * @example
- * ```typescript
- * import { CopilotClient } from "@github/copilot-sdk";
- *
- * // Create a client with default options (spawns CLI server)
- * const client = new CopilotClient();
- *
- * // Or connect to an existing server
- * const client = new CopilotClient({ connection: RuntimeConnection.forUri("localhost:3000") });
- *
- * // Create a session
- * const session = await client.createSession({ onPermissionRequest: approveAll, model: "gpt-4" });
- *
- * // Send messages and handle responses
- * session.on((event) => {
- *   if (event.type === "assistant.message") {
- *     console.log(event.data.content);
- *   }
- * });
- * await session.send({ prompt: "Hello!" });
- *
- * // Clean up
- * await session.disconnect();
- * await client.stop();
- * ```
- */
 export declare class CopilotClient {
     private cliStartTimeout;
     private cliProcess;
     private connection;
+    private messageWriter;
     private socket;
     private runtimePort;
     private actualHost;
@@ -67,12 +35,15 @@ export declare class CopilotClient {
     private negotiatedProtocolVersion;
     /** Connection-level session filesystem config, set via constructor option. */
     private sessionFsConfig;
+    private requestHandler;
+    private llmInferenceHandlers;
     /**
      * Typed server-scoped RPC methods.
      * @throws Error if the client is not connected
      */
     get rpc(): ReturnType<typeof createServerRpc>;
     private logDebugTiming;
+    private logDebug;
     /**
      * Creates a new CopilotClient instance.
      *
@@ -109,6 +80,7 @@ export declare class CopilotClient {
     private parseCliUrl;
     private validateSessionFsConfig;
     private setupSessionFs;
+    private setupLlmInference;
     /**
      * Starts the CLI server and establishes a connection.
      *